[thirdparty/glibc.git] / nptl / descr.h

/* Copyright (C) 2002-2020 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <https://www.gnu.org/licenses/>.  */

#ifndef _DESCR_H
#define _DESCR_H	1

#include <limits.h>
#include <sched.h>
#include <setjmp.h>
#include <stdbool.h>
#include <sys/types.h>
#include <hp-timing.h>
#include <list_t.h>
#include <lowlevellock.h>
#include <pthreaddef.h>
#include <dl-sysdep.h>
#include <thread_db.h>
#include <tls.h>
#include <unwind.h>
#include <bits/types/res_state.h>
#include <kernel-features.h>
#include <tls-internal-struct.h>

#ifndef TCB_ALIGNMENT
# define TCB_ALIGNMENT	sizeof (double)
#endif


/* We keep thread specific data in a special data structure, a two-level
   array.  The top-level array contains pointers to dynamically allocated
   arrays of a certain number of data pointers.  So we can implement a
   sparse array.  Each dynamic second-level array has
        PTHREAD_KEY_2NDLEVEL_SIZE
   entries.  This value shouldn't be too large.  */
#define PTHREAD_KEY_2NDLEVEL_SIZE       32

/* We need to address PTHREAD_KEYS_MAX key with PTHREAD_KEY_2NDLEVEL_SIZE
   keys in each subarray.  */
#define PTHREAD_KEY_1STLEVEL_SIZE \
  ((PTHREAD_KEYS_MAX + PTHREAD_KEY_2NDLEVEL_SIZE - 1) \
   / PTHREAD_KEY_2NDLEVEL_SIZE)


/* Internal version of the buffer to store cancellation handler
   information.  */
struct pthread_unwind_buf
{
  struct
  {
    __jmp_buf jmp_buf;
    int mask_was_saved;
  } cancel_jmp_buf[1];

  union
  {
    /* This is the placeholder of the public version.  */
    void *pad[4];

    struct
    {
      /* Pointer to the previous cleanup buffer.  */
      struct pthread_unwind_buf *prev;

      /* Backward compatibility: state of the old-style cleanup
	 handler at the time of the previous new-style cleanup handler
	 installment.  */
      struct _pthread_cleanup_buffer *cleanup;

      /* Cancellation type before the push call.  */
      int canceltype;
    } data;
  } priv;
};


/* Opcodes and data types for communication with the signal handler to
   change user/group IDs.  */
struct xid_command
{
  int syscall_no;
  /* Enforce zero-extension for the pointer argument in

     int setgroups (size_t size, const gid_t *list);

     The kernel XID arguments are unsigned and do not require sign
     extension.  */
  unsigned long int id[3];
  volatile int cntr;
  volatile int error; /* -1: no call yet, 0: success seen, >0: error seen.  */
};


/* Data structure used by the kernel to find robust futexes.  */
struct robust_list_head
{
  void *list;
  long int futex_offset;
  void *list_op_pending;
};


/* Data strcture used to handle thread priority protection.  */
struct priority_protection_data
{
  int priomax;
  unsigned int priomap[];
};


/* Thread descriptor data structure.  */
struct pthread
{
  union
  {
#if !TLS_DTV_AT_TP
    /* This overlaps the TCB as used for TLS without threads (see tls.h).  */
    tcbhead_t header;
#else
    struct
    {
      /* multiple_threads is enabled either when the process has spawned at
	 least one thread or when a single-threaded process cancels itself.
	 This enables additional code to introduce locking before doing some
	 compare_and_exchange operations and also enable cancellation points.
	 The concepts of multiple threads and cancellation points ideally
	 should be separate, since it is not necessary for multiple threads to
	 have been created for cancellation points to be enabled, as is the
	 case is when single-threaded process cancels itself.

	 Since enabling multiple_threads enables additional code in
	 cancellation points and compare_and_exchange operations, there is a
	 potential for an unneeded performance hit when it is enabled in a
	 single-threaded, self-canceling process.  This is OK though, since a
	 single-threaded process will enable async cancellation only when it
	 looks to cancel itself and is hence going to end anyway.  */
      int multiple_threads;
      int gscope_flag;
    } header;
#endif

    /* This extra padding has no special purpose, and this structure layout
       is private and subject to change without affecting the official ABI.
       We just have it here in case it might be convenient for some
       implementation-specific instrumentation hack or suchlike.  */
    void *__padding[24];
  };

  /* This descriptor's link on the `stack_used' or `__stack_user' list.  */
  list_t list;

  /* Thread ID - which is also a 'is this thread descriptor (and
     therefore stack) used' flag.  */
  pid_t tid;

  /* Ununsed.  */
  pid_t pid_ununsed;

  /* List of robust mutexes the thread is holding.  */
#if __PTHREAD_MUTEX_HAVE_PREV
  void *robust_prev;
  struct robust_list_head robust_head;

  /* The list above is strange.  It is basically a double linked list
     but the pointer to the next/previous element of the list points
     in the middle of the object, the __next element.  Whenever
     casting to __pthread_list_t we need to adjust the pointer
     first.
     These operations are effectively concurrent code in that the thread
     can get killed at any point in time and the kernel takes over.  Thus,
     the __next elements are a kind of concurrent list and we need to
     enforce using compiler barriers that the individual operations happen
     in such a way that the kernel always sees a consistent list.  The
     backward links (ie, the __prev elements) are not used by the kernel.
     FIXME We should use relaxed MO atomic operations here and signal fences
     because this kind of concurrency is similar to synchronizing with a
     signal handler.  */
# define QUEUE_PTR_ADJUST (offsetof (__pthread_list_t, __next))

# define ENQUEUE_MUTEX_BOTH(mutex, val)					      \
  do {									      \
    __pthread_list_t *next = (__pthread_list_t *)			      \
      ((((uintptr_t) THREAD_GETMEM (THREAD_SELF, robust_head.list)) & ~1ul)   \
       - QUEUE_PTR_ADJUST);						      \
    next->__prev = (void *) &mutex->__data.__list.__next;		      \
    mutex->__data.__list.__next = THREAD_GETMEM (THREAD_SELF,		      \
						 robust_head.list);	      \
    mutex->__data.__list.__prev = (void *) &THREAD_SELF->robust_head;	      \
    /* Ensure that the new list entry is ready before we insert it.  */	      \
    __asm ("" ::: "memory");						      \
    THREAD_SETMEM (THREAD_SELF, robust_head.list,			      \
		   (void *) (((uintptr_t) &mutex->__data.__list.__next)	      \
			     | val));					      \
  } while (0)
# define DEQUEUE_MUTEX(mutex) \
  do {									      \
    __pthread_list_t *next = (__pthread_list_t *)			      \
      ((char *) (((uintptr_t) mutex->__data.__list.__next) & ~1ul)	      \
       - QUEUE_PTR_ADJUST);						      \
    next->__prev = mutex->__data.__list.__prev;				      \
    __pthread_list_t *prev = (__pthread_list_t *)			      \
      ((char *) (((uintptr_t) mutex->__data.__list.__prev) & ~1ul)	      \
       - QUEUE_PTR_ADJUST);						      \
    prev->__next = mutex->__data.__list.__next;				      \
    /* Ensure that we remove the entry from the list before we change the     \
       __next pointer of the entry, which is read by the kernel.  */	      \
    __asm ("" ::: "memory");						      \
    mutex->__data.__list.__prev = NULL;					      \
    mutex->__data.__list.__next = NULL;					      \
  } while (0)
#else
  union
  {
    __pthread_slist_t robust_list;
    struct robust_list_head robust_head;
  };

# define ENQUEUE_MUTEX_BOTH(mutex, val)					      \
  do {									      \
    mutex->__data.__list.__next						      \
      = THREAD_GETMEM (THREAD_SELF, robust_list.__next);		      \
    /* Ensure that the new list entry is ready before we insert it.  */	      \
    __asm ("" ::: "memory");						      \
    THREAD_SETMEM (THREAD_SELF, robust_list.__next,			      \
		   (void *) (((uintptr_t) &mutex->__data.__list) | val));     \
  } while (0)
# define DEQUEUE_MUTEX(mutex) \
  do {									      \
    __pthread_slist_t *runp = (__pthread_slist_t *)			      \
      (((uintptr_t) THREAD_GETMEM (THREAD_SELF, robust_list.__next)) & ~1ul); \
    if (runp == &mutex->__data.__list)					      \
      THREAD_SETMEM (THREAD_SELF, robust_list.__next, runp->__next);	      \
    else								      \
      {									      \
	__pthread_slist_t *next = (__pthread_slist_t *)		      \
	  (((uintptr_t) runp->__next) & ~1ul);				      \
	while (next != &mutex->__data.__list)				      \
	  {								      \
	    runp = next;						      \
	    next = (__pthread_slist_t *) (((uintptr_t) runp->__next) & ~1ul); \
	  }								      \
									      \
	runp->__next = next->__next;					      \
	/* Ensure that we remove the entry from the list before we change the \
	   __next pointer of the entry, which is read by the kernel.  */      \
	    __asm ("" ::: "memory");					      \
	mutex->__data.__list.__next = NULL;				      \
      }									      \
  } while (0)
#endif
#define ENQUEUE_MUTEX(mutex) ENQUEUE_MUTEX_BOTH (mutex, 0)
#define ENQUEUE_MUTEX_PI(mutex) ENQUEUE_MUTEX_BOTH (mutex, 1)

  /* List of cleanup buffers.  */
  struct _pthread_cleanup_buffer *cleanup;

  /* Unwind information.  */
  struct pthread_unwind_buf *cleanup_jmp_buf;
#define HAVE_CLEANUP_JMP_BUF

  /* Flags determining processing of cancellation.  */
  int cancelhandling;
  /* Bit set if cancellation is disabled.  */
#define CANCELSTATE_BIT		0
#define CANCELSTATE_BITMASK	(0x01 << CANCELSTATE_BIT)
  /* Bit set if asynchronous cancellation mode is selected.  */
#define CANCELTYPE_BIT		1
#define CANCELTYPE_BITMASK	(0x01 << CANCELTYPE_BIT)
  /* Bit set if canceling has been initiated.  */
#define CANCELING_BIT		2
#define CANCELING_BITMASK	(0x01 << CANCELING_BIT)
  /* Bit set if canceled.  */
#define CANCELED_BIT		3
#define CANCELED_BITMASK	(0x01 << CANCELED_BIT)
  /* Bit set if thread is exiting.  */
#define EXITING_BIT		4
#define EXITING_BITMASK		(0x01 << EXITING_BIT)
  /* Bit set if thread terminated and TCB is freed.  */
#define TERMINATED_BIT		5
#define TERMINATED_BITMASK	(0x01 << TERMINATED_BIT)
  /* Bit set if thread is supposed to change XID.  */
#define SETXID_BIT		6
#define SETXID_BITMASK		(0x01 << SETXID_BIT)
  /* Mask for the rest.  Helps the compiler to optimize.  */
#define CANCEL_RESTMASK		0xffffff80

#define CANCEL_ENABLED_AND_CANCELED(value) \
  (((value) & (CANCELSTATE_BITMASK | CANCELED_BITMASK | EXITING_BITMASK	      \
	       | CANCEL_RESTMASK | TERMINATED_BITMASK)) == CANCELED_BITMASK)
#define CANCEL_ENABLED_AND_CANCELED_AND_ASYNCHRONOUS(value) \
  (((value) & (CANCELSTATE_BITMASK | CANCELTYPE_BITMASK | CANCELED_BITMASK    \
	       | EXITING_BITMASK | CANCEL_RESTMASK | TERMINATED_BITMASK))     \
   == (CANCELTYPE_BITMASK | CANCELED_BITMASK))

  /* Flags.  Including those copied from the thread attribute.  */
  int flags;

  /* We allocate one block of references here.  This should be enough
     to avoid allocating any memory dynamically for most applications.  */
  struct pthread_key_data
  {
    /* Sequence number.  We use uintptr_t to not require padding on
       32- and 64-bit machines.  On 64-bit machines it helps to avoid
       wrapping, too.  */
    uintptr_t seq;

    /* Data pointer.  */
    void *data;
  } specific_1stblock[PTHREAD_KEY_2NDLEVEL_SIZE];

  /* Two-level array for the thread-specific data.  */
  struct pthread_key_data *specific[PTHREAD_KEY_1STLEVEL_SIZE];

  /* Flag which is set when specific data is set.  */
  bool specific_used;

  /* True if events must be reported.  */
  bool report_events;

  /* True if the user provided the stack.  */
  bool user_stack;

  /* True if thread must stop at startup time.  */
  bool stopped_start;

  /* Formerly used for dealing with cancellation.  */
  int parent_cancelhandling_unsed;

  /* Lock to synchronize access to the descriptor.  */
  int lock;

  /* Lock for synchronizing setxid calls.  */
  unsigned int setxid_futex;

#if HP_TIMING_INLINE
  hp_timing_t cpuclock_offset_ununsed;
#endif

  /* If the thread waits to join another one the ID of the latter is
     stored here.

     In case a thread is detached this field contains a pointer of the
     TCB if the thread itself.  This is something which cannot happen
     in normal operation.  */
  struct pthread *joinid;
  /* Check whether a thread is detached.  */
#define IS_DETACHED(pd) ((pd)->joinid == (pd))

  /* The result of the thread function.  */
  void *result;

  /* Scheduling parameters for the new thread.  */
  struct sched_param schedparam;
  int schedpolicy;

  /* Start position of the code to be executed and the argument passed
     to the function.  */
  void *(*start_routine) (void *);
  void *arg;

  /* Debug state.  */
  td_eventbuf_t eventbuf;
  /* Next descriptor with a pending event.  */
  struct pthread *nextevent;

  /* Machine-specific unwind info.  */
  struct _Unwind_Exception exc;

  /* If nonzero, pointer to the area allocated for the stack and guard. */
  void *stackblock;
  /* Size of the stackblock area including the guard.  */
  size_t stackblock_size;
  /* Size of the included guard area.  */
  size_t guardsize;
  /* This is what the user specified and what we will report.  */
  size_t reported_guardsize;

  /* Thread Priority Protection data.  */
  struct priority_protection_data *tpp;

  /* Resolver state.  */
  struct __res_state res;

  /* Signal mask for the new thread.  Used during thread startup to
     restore the signal mask.  (Threads are launched with all signals
     masked.)  */
  sigset_t sigmask;

  /* Indicates whether is a C11 thread created by thrd_creat.  */
  bool c11;

  /* Used on strsignal.  */
  struct tls_internal_t tls_state;

  /* This member must be last.  */
  char end_padding[];

#define PTHREAD_STRUCT_END_PADDING \
  (sizeof (struct pthread) - offsetof (struct pthread, end_padding))
} __attribute ((aligned (TCB_ALIGNMENT)));


#endif	/* descr.h */
Commit	Line	Data
d614a753	1	/* Copyright (C) 2002-2020 Free Software Foundation, Inc.
76a50749 UD	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
59ba27a6	16	License along with the GNU C Library; if not, see
5a82c748	17	<https://www.gnu.org/licenses/>. */
76a50749 UD	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>
500b3a49	28	#include <list_t.h>
76a50749 UD	29	#include <lowlevellock.h>
76a50749 UD	30	#include <pthreaddef.h>
afb2e954	31	#include <dl-sysdep.h>
a198d37a	32	#include <thread_db.h>
d4f64e1a	33	#include <tls.h>
3e2ee6f0	34	#include <unwind.h>
500b3a49	35	#include <bits/types/res_state.h>
6df7ffad	36	#include <kernel-features.h>
9deec7c8	37	#include <tls-internal-struct.h>
76a50749 UD	38
	39	#ifndef TCB_ALIGNMENT
	40	# define TCB_ALIGNMENT sizeof (double)
	41	#endif
	42
	43
	44	/* We keep thread specific data in a special data structure, a two-level
	45	array. The top-level array contains pointers to dynamically allocated
	46	arrays of a certain number of data pointers. So we can implement a
	47	sparse array. Each dynamic second-level array has
	48	PTHREAD_KEY_2NDLEVEL_SIZE
	49	entries. This value shouldn't be too large. */
	50	#define PTHREAD_KEY_2NDLEVEL_SIZE 32
	51
	52	/* We need to address PTHREAD_KEYS_MAX key with PTHREAD_KEY_2NDLEVEL_SIZE
	53	keys in each subarray. */
	54	#define PTHREAD_KEY_1STLEVEL_SIZE \
	55	((PTHREAD_KEYS_MAX + PTHREAD_KEY_2NDLEVEL_SIZE - 1) \
	56	/ PTHREAD_KEY_2NDLEVEL_SIZE)
	57
	58
6efd4814 UD	59
	60
	61	/* Internal version of the buffer to store cancellation handler
	62	information. */
	63	struct pthread_unwind_buf
	64	{
68107ec0 UD	65	struct
	66	{
	67	__jmp_buf jmp_buf;
	68	int mask_was_saved;
	69	} cancel_jmp_buf[1];
	70
6efd4814 UD	71	union
	72	{
	73	/* This is the placeholder of the public version. */
68107ec0	74	void *pad[4];
6efd4814 UD	75
	76	struct
	77	{
6efd4814	78	/* Pointer to the previous cleanup buffer. */
49b65043	79	struct pthread_unwind_buf *prev;
6efd4814 UD	80
	81	/* Backward compatibility: state of the old-style cleanup
	82	handler at the time of the previous new-style cleanup handler
	83	installment. */
	84	struct _pthread_cleanup_buffer *cleanup;
	85
	86	/* Cancellation type before the push call. */
	87	int canceltype;
	88	} data;
	89	} priv;
6efd4814 UD	90	};
	91
	92
2edb61e3 UD	93	/* Opcodes and data types for communication with the signal handler to
	94	change user/group IDs. */
	95	struct xid_command
	96	{
	97	int syscall_no;
0ad926f3 L	98	/* Enforce zero-extension for the pointer argument in
	99
	100	int setgroups (size_t size, const gid_t *list);
	101
	102	The kernel XID arguments are unsigned and do not require sign
	103	extension. */
	104	unsigned long int id[3];
2edb61e3	105	volatile int cntr;
771eb141	106	volatile int error; /* -1: no call yet, 0: success seen, >0: error seen. */
2edb61e3 UD	107	};
	108
	109
0f6699ea UD	110	/* Data structure used by the kernel to find robust futexes. */
	111	struct robust_list_head
	112	{
	113	void *list;
	114	long int futex_offset;
	115	void *list_op_pending;
	116	};
	117
	118
f17efcb4 UD	119	/* Data strcture used to handle thread priority protection. */
	120	struct priority_protection_data
	121	{
	122	int priomax;
	123	unsigned int priomap[];
	124	};
	125
	126
76a50749 UD	127	/* Thread descriptor data structure. */
	128	struct pthread
	129	{
76a50749 UD	130	union
76a50749 UD	131	{
55c11fbd RM	132	#if !TLS_DTV_AT_TP
	133	/* This overlaps the TCB as used for TLS without threads (see tls.h). */
	134	tcbhead_t header;
bbde8527	135	#else
468777e1 UD	136	struct
468777e1 UD	137	{
439bf404 SP	138	/* multiple_threads is enabled either when the process has spawned at
	139	least one thread or when a single-threaded process cancels itself.
	140	This enables additional code to introduce locking before doing some
	141	compare_and_exchange operations and also enable cancellation points.
	142	The concepts of multiple threads and cancellation points ideally
	143	should be separate, since it is not necessary for multiple threads to
	144	have been created for cancellation points to be enabled, as is the
	145	case is when single-threaded process cancels itself.
	146
	147	Since enabling multiple_threads enables additional code in
	148	cancellation points and compare_and_exchange operations, there is a
	149	potential for an unneeded performance hit when it is enabled in a
	150	single-threaded, self-canceling process. This is OK though, since a
	151	single-threaded process will enable async cancellation only when it
	152	looks to cancel itself and is hence going to end anyway. */
468777e1	153	int multiple_threads;
991fa82b	154	int gscope_flag;
468777e1	155	} header;
d4f64e1a RM	156	#endif
d4f64e1a RM	157
55c11fbd RM	158	/* This extra padding has no special purpose, and this structure layout
	159	is private and subject to change without affecting the official ABI.
	160	We just have it here in case it might be convenient for some
	161	implementation-specific instrumentation hack or suchlike. */
9e9b8cb8	162	void *__padding[24];
55c11fbd RM	163	};
55c11fbd RM	164
d4f64e1a RM	165	/* This descriptor's link on the `stack_used' or `__stack_user' list. */
d4f64e1a RM	166	list_t list;
76a50749	167
bd8bb78b UD	168	/* Thread ID - which is also a 'is this thread descriptor (and
	169	therefore stack) used' flag. */
	170	pid_t tid;
	171
c579f48e AZ	172	/* Ununsed. */
c579f48e AZ	173	pid_t pid_ununsed;
cb5b9388	174
1bcfb5a5	175	/* List of robust mutexes the thread is holding. */
06be6368	176	#if __PTHREAD_MUTEX_HAVE_PREV
0f6699ea UD	177	void *robust_prev;
	178	struct robust_list_head robust_head;
	179
	180	/* The list above is strange. It is basically a double linked list
	181	but the pointer to the next/previous element of the list points
	182	in the middle of the object, the __next element. Whenever
	183	casting to __pthread_list_t we need to adjust the pointer
8f9450a0 TR	184	first.
	185	These operations are effectively concurrent code in that the thread
	186	can get killed at any point in time and the kernel takes over. Thus,
	187	the __next elements are a kind of concurrent list and we need to
	188	enforce using compiler barriers that the individual operations happen
	189	in such a way that the kernel always sees a consistent list. The
	190	backward links (ie, the __prev elements) are not used by the kernel.
	191	FIXME We should use relaxed MO atomic operations here and signal fences
	192	because this kind of concurrency is similar to synchronizing with a
	193	signal handler. */
0f6699ea	194	# define QUEUE_PTR_ADJUST (offsetof (__pthread_list_t, __next))
b007ce7c	195
df47504c	196	# define ENQUEUE_MUTEX_BOTH(mutex, val) \
1bcfb5a5	197	do { \
df47504c UD	198	__pthread_list_t next = (__pthread_list_t ) \
	199	((((uintptr_t) THREAD_GETMEM (THREAD_SELF, robust_head.list)) & ~1ul) \
	200	- QUEUE_PTR_ADJUST); \
0f6699ea	201	next->__prev = (void *) &mutex->__data.__list.__next; \
df47504c UD	202	mutex->__data.__list.__next = THREAD_GETMEM (THREAD_SELF, \
df47504c UD	203	robust_head.list); \
0f6699ea	204	mutex->__data.__list.__prev = (void *) &THREAD_SELF->robust_head; \
8f9450a0 TR	205	/* Ensure that the new list entry is ready before we insert it. */ \
8f9450a0 TR	206	__asm ("" ::: "memory"); \
0f6699ea	207	THREAD_SETMEM (THREAD_SELF, robust_head.list, \
df47504c UD	208	(void *) (((uintptr_t) &mutex->__data.__list.__next) \
df47504c UD	209	\| val)); \
1bcfb5a5 UD	210	} while (0)
	211	# define DEQUEUE_MUTEX(mutex) \
	212	do { \
0f6699ea	213	__pthread_list_t next = (__pthread_list_t ) \
df47504c UD	214	((char *) (((uintptr_t) mutex->__data.__list.__next) & ~1ul) \
df47504c UD	215	- QUEUE_PTR_ADJUST); \
0f6699ea UD	216	next->__prev = mutex->__data.__list.__prev; \
0f6699ea UD	217	__pthread_list_t prev = (__pthread_list_t ) \
df47504c UD	218	((char *) (((uintptr_t) mutex->__data.__list.__prev) & ~1ul) \
df47504c UD	219	- QUEUE_PTR_ADJUST); \
0f6699ea	220	prev->__next = mutex->__data.__list.__next; \
8f9450a0 TR	221	/* Ensure that we remove the entry from the list before we change the \
	222	__next pointer of the entry, which is read by the kernel. */ \
	223	__asm ("" ::: "memory"); \
b007ce7c UD	224	mutex->__data.__list.__prev = NULL; \
b007ce7c UD	225	mutex->__data.__list.__next = NULL; \
1bcfb5a5 UD	226	} while (0)
1bcfb5a5 UD	227	#else
0f6699ea UD	228	union
	229	{
	230	__pthread_slist_t robust_list;
	231	struct robust_list_head robust_head;
	232	};
b007ce7c	233
df47504c	234	# define ENQUEUE_MUTEX_BOTH(mutex, val) \
1bcfb5a5	235	do { \
b007ce7c UD	236	mutex->__data.__list.__next \
b007ce7c UD	237	= THREAD_GETMEM (THREAD_SELF, robust_list.__next); \
8f9450a0 TR	238	/* Ensure that the new list entry is ready before we insert it. */ \
8f9450a0 TR	239	__asm ("" ::: "memory"); \
df47504c	240	THREAD_SETMEM (THREAD_SELF, robust_list.__next, \
457b559e	241	(void *) (((uintptr_t) &mutex->__data.__list) \| val)); \
1bcfb5a5 UD	242	} while (0)
	243	# define DEQUEUE_MUTEX(mutex) \
	244	do { \
df47504c UD	245	__pthread_slist_t runp = (__pthread_slist_t ) \
df47504c UD	246	(((uintptr_t) THREAD_GETMEM (THREAD_SELF, robust_list.__next)) & ~1ul); \
b007ce7c	247	if (runp == &mutex->__data.__list) \
683040c3	248	THREAD_SETMEM (THREAD_SELF, robust_list.__next, runp->__next); \
1bcfb5a5 UD	249	else \
1bcfb5a5 UD	250	{ \
df47504c UD	251	__pthread_slist_t next = (__pthread_slist_t ) \
	252	(((uintptr_t) runp->__next) & ~1ul); \
	253	while (next != &mutex->__data.__list) \
	254	{ \
	255	runp = next; \
	256	next = (__pthread_slist_t *) (((uintptr_t) runp->__next) & ~1ul); \
	257	} \
1bcfb5a5	258	\
df47504c	259	runp->__next = next->__next; \
8f9450a0 TR	260	/* Ensure that we remove the entry from the list before we change the \
	261	__next pointer of the entry, which is read by the kernel. */ \
	262	__asm ("" ::: "memory"); \
b007ce7c	263	mutex->__data.__list.__next = NULL; \
1bcfb5a5 UD	264	} \
	265	} while (0)
	266	#endif
df47504c UD	267	#define ENQUEUE_MUTEX(mutex) ENQUEUE_MUTEX_BOTH (mutex, 0)
df47504c UD	268	#define ENQUEUE_MUTEX_PI(mutex) ENQUEUE_MUTEX_BOTH (mutex, 1)
1bcfb5a5	269
86bfff4d UD	270	/* List of cleanup buffers. */
	271	struct _pthread_cleanup_buffer *cleanup;
	272
6efd4814	273	/* Unwind information. */
49b65043	274	struct pthread_unwind_buf *cleanup_jmp_buf;
6efd4814 UD	275	#define HAVE_CLEANUP_JMP_BUF
6efd4814 UD	276
c70ad7d7 UD	277	/* Flags determining processing of cancellation. */
	278	int cancelhandling;
	279	/* Bit set if cancellation is disabled. */
	280	#define CANCELSTATE_BIT 0
bd03a1af	281	#define CANCELSTATE_BITMASK (0x01 << CANCELSTATE_BIT)
c70ad7d7 UD	282	/* Bit set if asynchronous cancellation mode is selected. */
c70ad7d7 UD	283	#define CANCELTYPE_BIT 1
bd03a1af	284	#define CANCELTYPE_BITMASK (0x01 << CANCELTYPE_BIT)
c70ad7d7 UD	285	/* Bit set if canceling has been initiated. */
c70ad7d7 UD	286	#define CANCELING_BIT 2
bd03a1af	287	#define CANCELING_BITMASK (0x01 << CANCELING_BIT)
c70ad7d7 UD	288	/* Bit set if canceled. */
c70ad7d7 UD	289	#define CANCELED_BIT 3
bd03a1af	290	#define CANCELED_BITMASK (0x01 << CANCELED_BIT)
c70ad7d7 UD	291	/* Bit set if thread is exiting. */
c70ad7d7 UD	292	#define EXITING_BIT 4
bd03a1af	293	#define EXITING_BITMASK (0x01 << EXITING_BIT)
c70ad7d7 UD	294	/* Bit set if thread terminated and TCB is freed. */
c70ad7d7 UD	295	#define TERMINATED_BIT 5
bd03a1af	296	#define TERMINATED_BITMASK (0x01 << TERMINATED_BIT)
dff9a7a1 UD	297	/* Bit set if thread is supposed to change XID. */
dff9a7a1 UD	298	#define SETXID_BIT 6
bd03a1af	299	#define SETXID_BITMASK (0x01 << SETXID_BIT)
c70ad7d7	300	/* Mask for the rest. Helps the compiler to optimize. */
dff9a7a1	301	#define CANCEL_RESTMASK 0xffffff80
c70ad7d7 UD	302
	303	#define CANCEL_ENABLED_AND_CANCELED(value) \
	304	(((value) & (CANCELSTATE_BITMASK \| CANCELED_BITMASK \| EXITING_BITMASK \
	305	\| CANCEL_RESTMASK \| TERMINATED_BITMASK)) == CANCELED_BITMASK)
	306	#define CANCEL_ENABLED_AND_CANCELED_AND_ASYNCHRONOUS(value) \
	307	(((value) & (CANCELSTATE_BITMASK \| CANCELTYPE_BITMASK \| CANCELED_BITMASK \
	308	\| EXITING_BITMASK \| CANCEL_RESTMASK \| TERMINATED_BITMASK)) \
	309	== (CANCELTYPE_BITMASK \| CANCELED_BITMASK))
5869d4ec	310
341c566f UD	311	/* Flags. Including those copied from the thread attribute. */
	312	int flags;
	313
5869d4ec UD	314	/* We allocate one block of references here. This should be enough
5869d4ec UD	315	to avoid allocating any memory dynamically for most applications. */
76a50749 UD	316	struct pthread_key_data
	317	{
	318	/* Sequence number. We use uintptr_t to not require padding on
	319	32- and 64-bit machines. On 64-bit machines it helps to avoid
	320	wrapping, too. */
	321	uintptr_t seq;
	322
	323	/* Data pointer. */
	324	void *data;
5869d4ec UD	325	} specific_1stblock[PTHREAD_KEY_2NDLEVEL_SIZE];
5869d4ec UD	326
a334319f UD	327	/* Two-level array for the thread-specific data. */
	328	struct pthread_key_data *specific[PTHREAD_KEY_1STLEVEL_SIZE];
	329
dff9a7a1 UD	330	/* Flag which is set when specific data is set. */
	331	bool specific_used;
	332
c70ad7d7 UD	333	/* True if events must be reported. */
	334	bool report_events;
	335
76a50749 UD	336	/* True if the user provided the stack. */
	337	bool user_stack;
	338
5f66b766 UD	339	/* True if thread must stop at startup time. */
	340	bool stopped_start;
	341
b3cae39d FW	342	/* Formerly used for dealing with cancellation. */
b3cae39d FW	343	int parent_cancelhandling_unsed;
b051fc44	344
5869d4ec	345	/* Lock to synchronize access to the descriptor. */
e51deae7	346	int lock;
76a50749	347
dff9a7a1	348	/* Lock for synchronizing setxid calls. */
45a8f0e6	349	unsigned int setxid_futex;
dff9a7a1	350
1e372ded	351	#if HP_TIMING_INLINE
38cc11da	352	hp_timing_t cpuclock_offset_ununsed;
76a50749 UD	353	#endif
	354
	355	/* If the thread waits to join another one the ID of the latter is
	356	stored here.
	357
	358	In case a thread is detached this field contains a pointer of the
	359	TCB if the thread itself. This is something which cannot happen
	360	in normal operation. */
	361	struct pthread *joinid;
	362	/* Check whether a thread is detached. */
	363	#define IS_DETACHED(pd) ((pd)->joinid == (pd))
	364
76a50749 UD	365	/* The result of the thread function. */
	366	void *result;
	367
	368	/* Scheduling parameters for the new thread. */
	369	struct sched_param schedparam;
	370	int schedpolicy;
	371
	372	/* Start position of the code to be executed and the argument passed
	373	to the function. */
	374	void (start_routine) (void *);
	375	void *arg;
	376
	377	/* Debug state. */
	378	td_eventbuf_t eventbuf;
	379	/* Next descriptor with a pending event. */
	380	struct pthread *nextevent;
	381
68107ec0 UD	382	/* Machine-specific unwind info. */
68107ec0 UD	383	struct _Unwind_Exception exc;
68107ec0	384
630f4cc3	385	/* If nonzero, pointer to the area allocated for the stack and guard. */
76a50749	386	void *stackblock;
630f4cc3	387	/* Size of the stackblock area including the guard. */
76a50749 UD	388	size_t stackblock_size;
	389	/* Size of the included guard area. */
	390	size_t guardsize;
5adac0e4 UD	391	/* This is what the user specified and what we will report. */
5adac0e4 UD	392	size_t reported_guardsize;
0e9d6240	393
f17efcb4 UD	394	/* Thread Priority Protection data. */
	395	struct priority_protection_data *tpp;
	396
0e9d6240 UD	397	/* Resolver state. */
0e9d6240 UD	398	struct __res_state res;
253eb3a0	399
b3cae39d FW	400	/* Signal mask for the new thread. Used during thread startup to
	401	restore the signal mask. (Threads are launched with all signals
	402	masked.) */
	403	sigset_t sigmask;
	404
ce7528f6 AZ	405	/* Indicates whether is a C11 thread created by thrd_creat. */
	406	bool c11;
	407
9deec7c8 AZ	408	/* Used on strsignal. */
	409	struct tls_internal_t tls_state;
	410
c5132ca1 RM	411	/* This member must be last. */
c5132ca1 RM	412	char end_padding[];
253eb3a0	413
c5132ca1 RM	414	#define PTHREAD_STRUCT_END_PADDING \
c5132ca1 RM	415	(sizeof (struct pthread) - offsetof (struct pthread, end_padding))
76a50749 UD	416	} __attribute ((aligned (TCB_ALIGNMENT)));
	417
	418
	419	#endif /* descr.h */