nptl/sysdeps/unix/sysv/linux/internaltypes.h

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