[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 GL (dl_stack_used) or
     GL (dl_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
1daccf40 FW	165	/* This descriptor's link on the GL (dl_stack_used) or
1daccf40 FW	166	GL (dl_stack_user) list. */
d4f64e1a	167	list_t list;
76a50749	168
bd8bb78b UD	169	/* Thread ID - which is also a 'is this thread descriptor (and
	170	therefore stack) used' flag. */
	171	pid_t tid;
	172
c579f48e AZ	173	/* Ununsed. */
c579f48e AZ	174	pid_t pid_ununsed;
cb5b9388	175
1bcfb5a5	176	/* List of robust mutexes the thread is holding. */
06be6368	177	#if __PTHREAD_MUTEX_HAVE_PREV
0f6699ea UD	178	void *robust_prev;
	179	struct robust_list_head robust_head;
	180
	181	/* The list above is strange. It is basically a double linked list
	182	but the pointer to the next/previous element of the list points
	183	in the middle of the object, the __next element. Whenever
	184	casting to __pthread_list_t we need to adjust the pointer
8f9450a0 TR	185	first.
	186	These operations are effectively concurrent code in that the thread
	187	can get killed at any point in time and the kernel takes over. Thus,
	188	the __next elements are a kind of concurrent list and we need to
	189	enforce using compiler barriers that the individual operations happen
	190	in such a way that the kernel always sees a consistent list. The
	191	backward links (ie, the __prev elements) are not used by the kernel.
	192	FIXME We should use relaxed MO atomic operations here and signal fences
	193	because this kind of concurrency is similar to synchronizing with a
	194	signal handler. */
0f6699ea	195	# define QUEUE_PTR_ADJUST (offsetof (__pthread_list_t, __next))
b007ce7c	196
df47504c	197	# define ENQUEUE_MUTEX_BOTH(mutex, val) \
1bcfb5a5	198	do { \
df47504c UD	199	__pthread_list_t next = (__pthread_list_t ) \
	200	((((uintptr_t) THREAD_GETMEM (THREAD_SELF, robust_head.list)) & ~1ul) \
	201	- QUEUE_PTR_ADJUST); \
0f6699ea	202	next->__prev = (void *) &mutex->__data.__list.__next; \
df47504c UD	203	mutex->__data.__list.__next = THREAD_GETMEM (THREAD_SELF, \
df47504c UD	204	robust_head.list); \
0f6699ea	205	mutex->__data.__list.__prev = (void *) &THREAD_SELF->robust_head; \
8f9450a0 TR	206	/* Ensure that the new list entry is ready before we insert it. */ \
8f9450a0 TR	207	__asm ("" ::: "memory"); \
0f6699ea	208	THREAD_SETMEM (THREAD_SELF, robust_head.list, \
df47504c UD	209	(void *) (((uintptr_t) &mutex->__data.__list.__next) \
df47504c UD	210	\| val)); \
1bcfb5a5 UD	211	} while (0)
	212	# define DEQUEUE_MUTEX(mutex) \
	213	do { \
0f6699ea	214	__pthread_list_t next = (__pthread_list_t ) \
df47504c UD	215	((char *) (((uintptr_t) mutex->__data.__list.__next) & ~1ul) \
df47504c UD	216	- QUEUE_PTR_ADJUST); \
0f6699ea UD	217	next->__prev = mutex->__data.__list.__prev; \
0f6699ea UD	218	__pthread_list_t prev = (__pthread_list_t ) \
df47504c UD	219	((char *) (((uintptr_t) mutex->__data.__list.__prev) & ~1ul) \
df47504c UD	220	- QUEUE_PTR_ADJUST); \
0f6699ea	221	prev->__next = mutex->__data.__list.__next; \
8f9450a0 TR	222	/* Ensure that we remove the entry from the list before we change the \
	223	__next pointer of the entry, which is read by the kernel. */ \
	224	__asm ("" ::: "memory"); \
b007ce7c UD	225	mutex->__data.__list.__prev = NULL; \
b007ce7c UD	226	mutex->__data.__list.__next = NULL; \
1bcfb5a5 UD	227	} while (0)
1bcfb5a5 UD	228	#else
0f6699ea UD	229	union
	230	{
	231	__pthread_slist_t robust_list;
	232	struct robust_list_head robust_head;
	233	};
b007ce7c	234
df47504c	235	# define ENQUEUE_MUTEX_BOTH(mutex, val) \
1bcfb5a5	236	do { \
b007ce7c UD	237	mutex->__data.__list.__next \
b007ce7c UD	238	= THREAD_GETMEM (THREAD_SELF, robust_list.__next); \
8f9450a0 TR	239	/* Ensure that the new list entry is ready before we insert it. */ \
8f9450a0 TR	240	__asm ("" ::: "memory"); \
df47504c	241	THREAD_SETMEM (THREAD_SELF, robust_list.__next, \
457b559e	242	(void *) (((uintptr_t) &mutex->__data.__list) \| val)); \
1bcfb5a5 UD	243	} while (0)
	244	# define DEQUEUE_MUTEX(mutex) \
	245	do { \
df47504c UD	246	__pthread_slist_t runp = (__pthread_slist_t ) \
df47504c UD	247	(((uintptr_t) THREAD_GETMEM (THREAD_SELF, robust_list.__next)) & ~1ul); \
b007ce7c	248	if (runp == &mutex->__data.__list) \
683040c3	249	THREAD_SETMEM (THREAD_SELF, robust_list.__next, runp->__next); \
1bcfb5a5 UD	250	else \
1bcfb5a5 UD	251	{ \
df47504c UD	252	__pthread_slist_t next = (__pthread_slist_t ) \
	253	(((uintptr_t) runp->__next) & ~1ul); \
	254	while (next != &mutex->__data.__list) \
	255	{ \
	256	runp = next; \
	257	next = (__pthread_slist_t *) (((uintptr_t) runp->__next) & ~1ul); \
	258	} \
1bcfb5a5	259	\
df47504c	260	runp->__next = next->__next; \
8f9450a0 TR	261	/* Ensure that we remove the entry from the list before we change the \
	262	__next pointer of the entry, which is read by the kernel. */ \
	263	__asm ("" ::: "memory"); \
b007ce7c	264	mutex->__data.__list.__next = NULL; \
1bcfb5a5 UD	265	} \
	266	} while (0)
	267	#endif
df47504c UD	268	#define ENQUEUE_MUTEX(mutex) ENQUEUE_MUTEX_BOTH (mutex, 0)
df47504c UD	269	#define ENQUEUE_MUTEX_PI(mutex) ENQUEUE_MUTEX_BOTH (mutex, 1)
1bcfb5a5	270
86bfff4d UD	271	/* List of cleanup buffers. */
	272	struct _pthread_cleanup_buffer *cleanup;
	273
6efd4814	274	/* Unwind information. */
49b65043	275	struct pthread_unwind_buf *cleanup_jmp_buf;
6efd4814 UD	276	#define HAVE_CLEANUP_JMP_BUF
6efd4814 UD	277
c70ad7d7 UD	278	/* Flags determining processing of cancellation. */
	279	int cancelhandling;
	280	/* Bit set if cancellation is disabled. */
	281	#define CANCELSTATE_BIT 0
bd03a1af	282	#define CANCELSTATE_BITMASK (0x01 << CANCELSTATE_BIT)
c70ad7d7 UD	283	/* Bit set if asynchronous cancellation mode is selected. */
c70ad7d7 UD	284	#define CANCELTYPE_BIT 1
bd03a1af	285	#define CANCELTYPE_BITMASK (0x01 << CANCELTYPE_BIT)
c70ad7d7 UD	286	/* Bit set if canceling has been initiated. */
c70ad7d7 UD	287	#define CANCELING_BIT 2
bd03a1af	288	#define CANCELING_BITMASK (0x01 << CANCELING_BIT)
c70ad7d7 UD	289	/* Bit set if canceled. */
c70ad7d7 UD	290	#define CANCELED_BIT 3
bd03a1af	291	#define CANCELED_BITMASK (0x01 << CANCELED_BIT)
c70ad7d7 UD	292	/* Bit set if thread is exiting. */
c70ad7d7 UD	293	#define EXITING_BIT 4
bd03a1af	294	#define EXITING_BITMASK (0x01 << EXITING_BIT)
c70ad7d7 UD	295	/* Bit set if thread terminated and TCB is freed. */
c70ad7d7 UD	296	#define TERMINATED_BIT 5
bd03a1af	297	#define TERMINATED_BITMASK (0x01 << TERMINATED_BIT)
dff9a7a1 UD	298	/* Bit set if thread is supposed to change XID. */
dff9a7a1 UD	299	#define SETXID_BIT 6
bd03a1af	300	#define SETXID_BITMASK (0x01 << SETXID_BIT)
c70ad7d7	301	/* Mask for the rest. Helps the compiler to optimize. */
dff9a7a1	302	#define CANCEL_RESTMASK 0xffffff80
c70ad7d7 UD	303
	304	#define CANCEL_ENABLED_AND_CANCELED(value) \
	305	(((value) & (CANCELSTATE_BITMASK \| CANCELED_BITMASK \| EXITING_BITMASK \
	306	\| CANCEL_RESTMASK \| TERMINATED_BITMASK)) == CANCELED_BITMASK)
	307	#define CANCEL_ENABLED_AND_CANCELED_AND_ASYNCHRONOUS(value) \
	308	(((value) & (CANCELSTATE_BITMASK \| CANCELTYPE_BITMASK \| CANCELED_BITMASK \
	309	\| EXITING_BITMASK \| CANCEL_RESTMASK \| TERMINATED_BITMASK)) \
	310	== (CANCELTYPE_BITMASK \| CANCELED_BITMASK))
5869d4ec	311
341c566f UD	312	/* Flags. Including those copied from the thread attribute. */
	313	int flags;
	314
5869d4ec UD	315	/* We allocate one block of references here. This should be enough
5869d4ec UD	316	to avoid allocating any memory dynamically for most applications. */
76a50749 UD	317	struct pthread_key_data
	318	{
	319	/* Sequence number. We use uintptr_t to not require padding on
	320	32- and 64-bit machines. On 64-bit machines it helps to avoid
	321	wrapping, too. */
	322	uintptr_t seq;
	323
	324	/* Data pointer. */
	325	void *data;
5869d4ec UD	326	} specific_1stblock[PTHREAD_KEY_2NDLEVEL_SIZE];
5869d4ec UD	327
a334319f UD	328	/* Two-level array for the thread-specific data. */
	329	struct pthread_key_data *specific[PTHREAD_KEY_1STLEVEL_SIZE];
	330
dff9a7a1 UD	331	/* Flag which is set when specific data is set. */
	332	bool specific_used;
	333
c70ad7d7 UD	334	/* True if events must be reported. */
	335	bool report_events;
	336
76a50749 UD	337	/* True if the user provided the stack. */
	338	bool user_stack;
	339
5f66b766 UD	340	/* True if thread must stop at startup time. */
	341	bool stopped_start;
	342
b3cae39d FW	343	/* Formerly used for dealing with cancellation. */
b3cae39d FW	344	int parent_cancelhandling_unsed;
b051fc44	345
5869d4ec	346	/* Lock to synchronize access to the descriptor. */
e51deae7	347	int lock;
76a50749	348
dff9a7a1	349	/* Lock for synchronizing setxid calls. */
45a8f0e6	350	unsigned int setxid_futex;
dff9a7a1	351
1e372ded	352	#if HP_TIMING_INLINE
38cc11da	353	hp_timing_t cpuclock_offset_ununsed;
76a50749 UD	354	#endif
	355
	356	/* If the thread waits to join another one the ID of the latter is
	357	stored here.
	358
	359	In case a thread is detached this field contains a pointer of the
	360	TCB if the thread itself. This is something which cannot happen
	361	in normal operation. */
	362	struct pthread *joinid;
	363	/* Check whether a thread is detached. */
	364	#define IS_DETACHED(pd) ((pd)->joinid == (pd))
	365
76a50749 UD	366	/* The result of the thread function. */
	367	void *result;
	368
	369	/* Scheduling parameters for the new thread. */
	370	struct sched_param schedparam;
	371	int schedpolicy;
	372
	373	/* Start position of the code to be executed and the argument passed
	374	to the function. */
	375	void (start_routine) (void *);
	376	void *arg;
	377
	378	/* Debug state. */
	379	td_eventbuf_t eventbuf;
	380	/* Next descriptor with a pending event. */
	381	struct pthread *nextevent;
	382
68107ec0 UD	383	/* Machine-specific unwind info. */
68107ec0 UD	384	struct _Unwind_Exception exc;
68107ec0	385
630f4cc3	386	/* If nonzero, pointer to the area allocated for the stack and guard. */
76a50749	387	void *stackblock;
630f4cc3	388	/* Size of the stackblock area including the guard. */
76a50749 UD	389	size_t stackblock_size;
	390	/* Size of the included guard area. */
	391	size_t guardsize;
5adac0e4 UD	392	/* This is what the user specified and what we will report. */
5adac0e4 UD	393	size_t reported_guardsize;
0e9d6240	394
f17efcb4 UD	395	/* Thread Priority Protection data. */
	396	struct priority_protection_data *tpp;
	397
0e9d6240 UD	398	/* Resolver state. */
0e9d6240 UD	399	struct __res_state res;
253eb3a0	400
b3cae39d FW	401	/* Signal mask for the new thread. Used during thread startup to
	402	restore the signal mask. (Threads are launched with all signals
	403	masked.) */
	404	sigset_t sigmask;
	405
ce7528f6 AZ	406	/* Indicates whether is a C11 thread created by thrd_creat. */
	407	bool c11;
	408
9deec7c8 AZ	409	/* Used on strsignal. */
	410	struct tls_internal_t tls_state;
	411
c5132ca1 RM	412	/* This member must be last. */
c5132ca1 RM	413	char end_padding[];
253eb3a0	414
c5132ca1 RM	415	#define PTHREAD_STRUCT_END_PADDING \
c5132ca1 RM	416	(sizeof (struct pthread) - offsetof (struct pthread, end_padding))
76a50749 UD	417	} __attribute ((aligned (TCB_ALIGNMENT)));
	418
	419
	420	#endif /* descr.h */