[thirdparty/glibc.git] / nptl / sysdeps / unix / sysv / linux / internaltypes.h

/* Copyright (C) 2002, 2003 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, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

#ifndef _INTERNALTYPES_H
#define _INTERNALTYPES_H	1

#include <stdint.h>


struct pthread_attr
{
  /* Scheduler parameters and priority.  */
  struct sched_param schedparam;
  int schedpolicy;
  /* Various flags like detachstate, scope, etc.  */
  int flags;
  /* Size of guard area.  */
  size_t guardsize;
  /* Stack handling.  */
  void *stackaddr;
  size_t stacksize;

  /* Chain of all initialized attributes.  Keep this last since it is
     not always used.  */
  struct pthread_attr *next;
};

#define ATTR_FLAG_DETACHSTATE		0x0001
#define ATTR_FLAG_NOTINHERITSCHED	0x0002
#define ATTR_FLAG_SCOPEPROCESS		0x0004
#define ATTR_FLAG_STACKADDR		0x0008


/* Mutex attribute data structure.  */
struct pthread_mutexattr
{
  /* Identifier for the kind of mutex.

     Bit 31 is set if the mutex is to be shared between processes.

     Bit 0 to 30 contain one of the PTHREAD_MUTEX_ values to identify
     the type of the mutex.  */
  int mutexkind;
};


/* Conditional variable attribute data structure.  */
struct pthread_condattr
{
  /* Flag whether coditional variable will be shareable between processes.  */
  int pshared;
};


/* Read-write lock variable attribute data structure.  */
struct pthread_rwlockattr
{
  int lockkind;
  int pshared;
};


/* Barrier data structure.  */
struct pthread_barrier
{
  unsigned int curr_event;
  int lock;
  unsigned int left;
  unsigned int init_count;
};


/* Barrier variable attribute data structure.  */
struct pthread_barrierattr
{
  int pshared;
};


/* Thread-local data handling.  */
struct pthread_key_struct
{
  /* Sequence numbers.  Even numbers indicated vacant entries.  Note
     that zero is even.  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;

  /* Destructor for the data.  */
  void (*destr) (void *);
};

/* Check whether an entry is unused.  */
#define KEY_UNUSED(p) (((p) & 1) == 0)
/* Check whether a key is usable.  We cannot reuse an allocated key if
   the sequence counter would overflow after the next destroy call.
   This would mean that we potentially free memory for a key with the
   same sequence.  This is *very* unlikely to happen, A program would
   have to create and destroy a key 2^31 times (on 32-bit platforms,
   on 64-bit platforms that would be 2^63).  If it should happen we
   simply don't use this specific key anymore.  */
#define KEY_USABLE(p) (((uintptr_t) (p)) < ((uintptr_t) ((p) + 2)))


/* Handling of read-write lock data.  */
// XXX For now there is only one flag.  Maybe more in future.
#define RWLOCK_RECURSIVE(rwlock) ((rwlock)->__data.__flags != 0)


/* Semaphore variable structure.  */
struct sem
{
  unsigned int count;
};


/* Compatibility type for old conditional variable interfaces.  */
typedef struct
{
  pthread_cond_t *cond;
} pthread_cond_2_0_t;

#endif	/* internaltypes.h */
Commit	Line	Data
73e9ae88	1	/* Copyright (C) 2002, 2003 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
	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 _INTERNALTYPES_H
	21	#define _INTERNALTYPES_H 1
	22
73e9ae88 UD	23	#include <stdint.h>
73e9ae88 UD	24
76a50749 UD	25
	26	struct pthread_attr
	27	{
	28	/* Scheduler parameters and priority. */
	29	struct sched_param schedparam;
	30	int schedpolicy;
	31	/* Various flags like detachstate, scope, etc. */
	32	int flags;
	33	/* Size of guard area. */
	34	size_t guardsize;
	35	/* Stack handling. */
	36	void *stackaddr;
	37	size_t stacksize;
	38
	39	/* Chain of all initialized attributes. Keep this last since it is
	40	not always used. */
	41	struct pthread_attr *next;
	42	};
	43
	44	#define ATTR_FLAG_DETACHSTATE 0x0001
	45	#define ATTR_FLAG_NOTINHERITSCHED 0x0002
	46	#define ATTR_FLAG_SCOPEPROCESS 0x0004
	47	#define ATTR_FLAG_STACKADDR 0x0008
	48
	49
	50	/* Mutex attribute data structure. */
	51	struct pthread_mutexattr
	52	{
	53	/* Identifier for the kind of mutex.
	54
	55	Bit 31 is set if the mutex is to be shared between processes.
	56
	57	Bit 0 to 30 contain one of the PTHREAD_MUTEX_ values to identify
	58	the type of the mutex. */
	59	int mutexkind;
	60	};
	61
	62
	63	/* Conditional variable attribute data structure. */
	64	struct pthread_condattr
	65	{
	66	/* Flag whether coditional variable will be shareable between processes. */
	67	int pshared;
	68	};
	69
	70
	71	/* Read-write lock variable attribute data structure. */
	72	struct pthread_rwlockattr
	73	{
	74	int lockkind;
	75	int pshared;
	76	};
	77
	78
	79	/* Barrier data structure. */
	80	struct pthread_barrier
	81	{
	82	unsigned int curr_event;
	83	int lock;
	84	unsigned int left;
	85	unsigned int init_count;
	86	};
	87
	88
89	/* Barrier variable attribute data structure. */
90	struct pthread_barrierattr
91	{
92	int pshared;
93	};
94
95
96	/* Thread-local data handling. */
97	struct pthread_key_struct
98	{
99	/* Sequence numbers. Even numbers indicated vacant entries. Note
100	that zero is even. We use uintptr_t to not require padding on
101	32- and 64-bit machines. On 64-bit machines it helps to avoid
102	wrapping, too. */
103	uintptr_t seq;
104
105	/* Destructor for the data. */
106	void (destr) (void );
107	};
108
109	/* Check whether an entry is unused. */
110	#define KEY_UNUSED(p) (((p) & 1) == 0)
111	/* Check whether a key is usable. We cannot reuse an allocated key if
112	the sequence counter would overflow after the next destroy call.
113	This would mean that we potentially free memory for a key with the
114	same sequence. This is very unlikely to happen, A program would
115	have to create and destroy a key 2^31 times (on 32-bit platforms,
116	on 64-bit platforms that would be 2^63). If it should happen we
117	simply don't use this specific key anymore. */
118	#define KEY_USABLE(p) (((uintptr_t) (p)) < ((uintptr_t) ((p) + 2)))
119
120
121	/* Handling of read-write lock data. */
122	// XXX For now there is only one flag. Maybe more in future.
123	#define RWLOCK_RECURSIVE(rwlock) ((rwlock)->__data.__flags != 0)
124
125
126	/* Semaphore variable structure. */
127	struct sem
128	{
129	unsigned int count;
130	};
131
73e9ae88 UD	132
	133	/* Compatibility type for old conditional variable interfaces. */
	134	typedef struct
	135	{
	136	pthread_cond_t *cond;
	137	} pthread_cond_2_0_t;
	138
76a50749	139	#endif /* internaltypes.h */