Avoid exposing internals of structures

* sysdeps/generic/bits/barrier-attr.h (__pthread_barrierattr): Rename
`pshared' field to `__pshared'.
* sysdeps/generic/bits/barrier.h (__pthread_barrier): Rename `lock',
`'queue', `pending', `count', `attr', and `data' fields to `__lock',
`__queue', `__pending', `__count', `__attr', and `__data'.
* sysdeps/generic/bits/cancelation.h (__pthread_cancelation_handler): Rename
`handler', `arg', and `next' fields to `__handler', `__arg', and `__next'.
* sysdeps/generic/bits/condition-attr.h (__pthread_condattr): Rename
`pshared' and `clock' fields to `__pshared', and `__clock'.
* sysdeps/generic/bits/mutex-attr.h (__pthread_mutexattr): Rename
`prioceiling', `protocol', `pshared', and `mutex_type' fields to
`__prioceiling', `__protocol', `__pshared', and `__mutex_type'.
* sysdeps/generic/bits/mutex.h (__pthread_mutex): Rename `cthreadscompat1',
`attr', `data', `owner', and `locks' fields to `__cthreadscompat1',
`__attr', `__data', `__owner', and `__locks'.
* sysdeps/generic/bits/once.h (__pthread_once): Rename `run' and `lock'
fields to `__run' and `__lock'.
* sysdeps/generic/bits/rwlock-attr.h (__pthread_rwlockattr): Rename
`psharead' field to `__pshared'.
* sysdeps/generic/bits/rwlock.h (__pthread_rwlock): Rename `readers',
`readerqueue', and `writerqueue' fields to `__readers', `__readerqueue', and
`__writerqueue'.
* sysdeps/generic/bits/thread-attr.h (__pthread_contentionscope): Rename
`schedparam', `stackaddr', `stacksize', `guardsize', `detachstate',
`inheritsched', `contentionscope', and `schedpolicy' fields to
`__schedparam', `__stackaddr', `__stacksize', `__guardsize',
`__detachstate', `__inheritsched', `__contentionscope', and
`__schedpolicy''.
* sysdeps/generic/bits/cancelation.h: Update code accordingly.
* pthread/pt-create.c: Likewise.
* pthread/pt-exit.c: Likewise.
* pthread/pt-getattr.c: Likewise.
* sysdeps/generic/pt-attr-getdetachstate.c: Likewise.
* sysdeps/generic/pt-attr-getguardsize.c: Likewise.
* sysdeps/generic/pt-attr-getinheritsched.c: Likewise.
* sysdeps/generic/pt-attr-getschedparam.c: Likewise.
* sysdeps/generic/pt-attr-getschedpolicy.c: Likewise.
* sysdeps/generic/pt-attr-getscope.c: Likewise.
* sysdeps/generic/pt-attr-getstackaddr.c: Likewise.
* sysdeps/generic/pt-attr-getstacksize.c: Likewise.
* sysdeps/generic/pt-attr-setdetachstate.c: Likewise.
* sysdeps/generic/pt-attr-setguardsize.c: Likewise.
* sysdeps/generic/pt-attr-setinheritsched.c: Likewise.
* sysdeps/generic/pt-attr-setschedparam.c: Likewise.
* sysdeps/generic/pt-attr-setschedpolicy.c: Likewise.
* sysdeps/generic/pt-attr-setscope.c: Likewise.
* sysdeps/generic/pt-attr-setstackaddr.c: Likewise.
* sysdeps/generic/pt-attr-setstacksize.c: Likewise.
* sysdeps/generic/pt-attr.c: Likewise.
* sysdeps/generic/pt-barrier-init.c: Likewise.
* sysdeps/generic/pt-barrier-wait.c: Likewise.
* sysdeps/generic/pt-barrier.c: Likewise.
* sysdeps/generic/pt-barrierattr-getpshared.c: Likewise.
* sysdeps/generic/pt-barrierattr-setpshared.c: Likewise.
* sysdeps/generic/pt-cond-timedwait.c: Likewise.
* sysdeps/generic/pt-cond.c: Likewise.
* sysdeps/generic/pt-condattr-getclock.c: Likewise.
* sysdeps/generic/pt-condattr-getpshared.c: Likewise.
* sysdeps/generic/pt-condattr-setclock.c: Likewise.
* sysdeps/generic/pt-condattr-setpshared.c: Likewise.
* sysdeps/generic/pt-mutex-destroy.c: Likewise.
* sysdeps/generic/pt-mutex-init.c: Likewise.
* sysdeps/generic/pt-mutex-timedlock.c: Likewise.
* sysdeps/generic/pt-mutex-transfer-np.c: Likewise.
* sysdeps/generic/pt-mutex-trylock.c: Likewise.
* sysdeps/generic/pt-mutex-unlock.c: Likewise.
* sysdeps/generic/pt-mutexattr-getprotocol.c: Likewise.
* sysdeps/generic/pt-mutexattr-getpshared.c: Likewise.
* sysdeps/generic/pt-mutexattr-gettype.c: Likewise.
* sysdeps/generic/pt-mutexattr-setprotocol.c: Likewise.
* sysdeps/generic/pt-mutexattr-setpshared.c: Likewise.
* sysdeps/generic/pt-mutexattr-settype.c: Likewise.
* sysdeps/generic/pt-mutexattr.c: Likewise.
* sysdeps/generic/pt-once.c: Likewise.
* sysdeps/generic/pt-rwlock-attr.c: Likewise.
* sysdeps/generic/pt-rwlock-timedrdlock.c: Likewise.
* sysdeps/generic/pt-rwlock-timedwrlock.c: Likewise.
* sysdeps/generic/pt-rwlock-tryrdlock.c: Likewise.
* sysdeps/generic/pt-rwlock-trywrlock.c: Likewise.
* sysdeps/generic/pt-rwlock-unlock.c: Likewise.
* sysdeps/generic/pt-rwlockattr-getpshared.c: Likewise.
* sysdeps/generic/pt-rwlockattr-setpshared.c: Likewise.
* sysdeps/mach/hurd/pt-attr-setstackaddr.c: Likewise.
* sysdeps/mach/hurd/pt-attr-setstacksize.c: Likewise.
* sysdeps/mach/hurd/pt-hurd-cond-timedwait.c: Likewise.

63 files changed, 215 insertions, 215 deletions

diff --git a/sysdeps/generic/bits/barrier-attr.h b/sysdeps/generic/bits/barrier-attr.h
index a9900b7..7734069 100644
--- a/sysdeps/generic/bits/barrier-attr.h
+++ b/sysdeps/generic/bits/barrier-attr.h
@@ -26,7 +26,7 @@ enum __pthread_process_shared;
    Note that not all of them are supported on all systems.  */
 struct __pthread_barrierattr
 {
-  enum __pthread_process_shared pshared;
+  enum __pthread_process_shared __pshared;
 };
 
 #endif /* bits/barrier-attr.h */
diff --git a/sysdeps/generic/bits/barrier.h b/sysdeps/generic/bits/barrier.h
index 5e55931..dabe86f 100644
--- a/sysdeps/generic/bits/barrier.h
+++ b/sysdeps/generic/bits/barrier.h
@@ -25,14 +25,14 @@
 /* This structure describes the attributes of a POSIX barrier.  */
 struct __pthread_barrier
 {
-  __pthread_spinlock_t lock;
-  struct __pthread *queue; /* List of waiters.  */
-  unsigned pending;	/* Number of that still need to wait on
+  __pthread_spinlock_t __lock;
+  struct __pthread *__queue; /* List of waiters.  */
+  unsigned __pending;	/* Number of that still need to wait on
 			   barrier.  */
-  unsigned count;	/* Number of threads that must wait before
+  unsigned __count;	/* Number of threads that must wait before
 			   barrier is passed.  */
-  struct __pthread_barrierattr *attr;
-  void *data;
+  struct __pthread_barrierattr *__attr;
+  void *__data;
 };
 
 
diff --git a/sysdeps/generic/bits/cancelation.h b/sysdeps/generic/bits/cancelation.h
index 46486f5..1ed16c6 100644
--- a/sysdeps/generic/bits/cancelation.h
+++ b/sysdeps/generic/bits/cancelation.h
@@ -22,9 +22,9 @@
 
 struct __pthread_cancelation_handler
 {
-  void (*handler)(void *);
-  void *arg;
-  struct __pthread_cancelation_handler *next;
+  void (*__handler)(void *);
+  void *__arg;
+  struct __pthread_cancelation_handler *__next;
 };
 
 /* Returns the thread local location of the cleanup handler stack.  */
@@ -44,8 +44,8 @@ struct __pthread_cancelation_handler **__pthread_get_cleanup_stack (void);
 	  
 #define __pthread_cleanup_pop(execute) \
 	  if (execute) \
-	    __handler.handler (__handler.arg); \
-	  *__handlers = __handler.next; \
+	    __handler.__handler (__handler.__arg); \
+	  *__handlers = __handler.__next; \
 	}
 
 #endif /* _BITS_CANCELATION_H */
diff --git a/sysdeps/generic/bits/condition-attr.h b/sysdeps/generic/bits/condition-attr.h
index 4cd4e8c..19c92bb 100644
--- a/sysdeps/generic/bits/condition-attr.h
+++ b/sysdeps/generic/bits/condition-attr.h
@@ -27,8 +27,8 @@ enum __pthread_process_shared;
 /* User visible part of a condition attribute variable.  */
 struct __pthread_condattr
   {
-    enum __pthread_process_shared pshared;
-    __clockid_t clock;
+    enum __pthread_process_shared __pshared;
+    __clockid_t __clock;
   };
 
 #endif /* bits/condition.h */
diff --git a/sysdeps/generic/bits/mutex-attr.h b/sysdeps/generic/bits/mutex-attr.h
index 8514ebe..f3d0752 100644
--- a/sysdeps/generic/bits/mutex-attr.h
+++ b/sysdeps/generic/bits/mutex-attr.h
@@ -28,10 +28,10 @@ enum __pthread_mutex_type;
    attribute.  */
 struct __pthread_mutexattr
 {
-  int prioceiling;
-  enum __pthread_mutex_protocol protocol;
-  enum __pthread_process_shared pshared;
-  enum __pthread_mutex_type mutex_type;
+  int __prioceiling;
+  enum __pthread_mutex_protocol __protocol;
+  enum __pthread_process_shared __pshared;
+  enum __pthread_mutex_type __mutex_type;
 };
 
 /* Attributes for a recursive mutex.  */
diff --git a/sysdeps/generic/bits/mutex.h b/sysdeps/generic/bits/mutex.h
index c734c39..3120237 100644
--- a/sysdeps/generic/bits/mutex.h
+++ b/sysdeps/generic/bits/mutex.h
@@ -41,14 +41,14 @@ struct __pthread_mutex
     __pthread_spinlock_t __lock;
     /* In cthreads, mutex_init does not initialized thre third
        pointer, as such, we cannot rely on its value for anything.  */
-    char *cthreadscompat1;
+    char *__cthreadscompat1;
     struct __pthread *__queue;
-    struct __pthread_mutexattr *attr;
-    void *data;
+    struct __pthread_mutexattr *__attr;
+    void *__data;
     /*  Up to this point, we are completely compatible with cthreads
 	and what libc expects.  */
-    void *owner;
-    unsigned locks;
+    void *__owner;
+    unsigned __locks;
     /* If NULL then the default attributes apply.  */
   };
 
diff --git a/sysdeps/generic/bits/once.h b/sysdeps/generic/bits/once.h
index f4985d6..05895b9 100644
--- a/sysdeps/generic/bits/once.h
+++ b/sysdeps/generic/bits/once.h
@@ -24,8 +24,8 @@
 
 struct __pthread_once
 {
-  int run;
-  __pthread_spinlock_t lock;
+  int __run;
+  __pthread_spinlock_t __lock;
 };
 
 #define __PTHREAD_ONCE_INIT \
diff --git a/sysdeps/generic/bits/rwlock-attr.h b/sysdeps/generic/bits/rwlock-attr.h
index dba99f1..e78b91e 100644
--- a/sysdeps/generic/bits/rwlock-attr.h
+++ b/sysdeps/generic/bits/rwlock-attr.h
@@ -26,7 +26,7 @@ enum __pthread_process_shared;
    Note that not all of them are supported on all systems.  */
 struct __pthread_rwlockattr
 {
-  enum __pthread_process_shared pshared;
+  enum __pthread_process_shared __pshared;
 };
 
 #endif /* bits/rwlock-attr.h */
diff --git a/sysdeps/generic/bits/rwlock.h b/sysdeps/generic/bits/rwlock.h
index af6b1c8..bc27726 100644
--- a/sysdeps/generic/bits/rwlock.h
+++ b/sysdeps/generic/bits/rwlock.h
@@ -31,9 +31,9 @@ struct __pthread_rwlock
   {
     __pthread_spinlock_t __held;
     __pthread_spinlock_t __lock;
-    int readers;
-    struct __pthread *readerqueue;
-    struct __pthread *writerqueue;
+    int __readers;
+    struct __pthread *__readerqueue;
+    struct __pthread *__writerqueue;
     struct __pthread_rwlockattr *__attr;
     void *__data;
   };
diff --git a/sysdeps/generic/bits/thread-attr.h b/sysdeps/generic/bits/thread-attr.h
index 9a8fb75..d9456b0 100644
--- a/sysdeps/generic/bits/thread-attr.h
+++ b/sysdeps/generic/bits/thread-attr.h
@@ -34,14 +34,14 @@ enum __pthread_contentionscope;
    that not all of them are supported on all systems.  */
 struct __pthread_attr
 {
-  struct __sched_param schedparam;
-  void *stackaddr;
-  size_t stacksize;
-  size_t guardsize;
-  enum __pthread_detachstate detachstate;
-  enum __pthread_inheritsched inheritsched;
-  enum __pthread_contentionscope contentionscope;
-  int schedpolicy;
+  struct __sched_param __schedparam;
+  void *__stackaddr;
+  size_t __stacksize;
+  size_t __guardsize;
+  enum __pthread_detachstate __detachstate;
+  enum __pthread_inheritsched __inheritsched;
+  enum __pthread_contentionscope __contentionscope;
+  int __schedpolicy;
 };
 
 #endif /* bits/thread-attr.h */
diff --git a/sysdeps/generic/pt-attr-getdetachstate.c b/sysdeps/generic/pt-attr-getdetachstate.c
index b50f913..6a1de67 100644
--- a/sysdeps/generic/pt-attr-getdetachstate.c
+++ b/sysdeps/generic/pt-attr-getdetachstate.c
@@ -24,7 +24,7 @@ int
 __pthread_attr_getdetachstate (const pthread_attr_t *attr,
 			     int *detachstate)
 {
-  *detachstate = attr->detachstate;
+  *detachstate = attr->__detachstate;
   return 0;
 }
 
diff --git a/sysdeps/generic/pt-attr-getguardsize.c b/sysdeps/generic/pt-attr-getguardsize.c
index c1d9f13..909f301 100644
--- a/sysdeps/generic/pt-attr-getguardsize.c
+++ b/sysdeps/generic/pt-attr-getguardsize.c
@@ -24,6 +24,6 @@ int
 pthread_attr_getguardsize (const pthread_attr_t *attr,
 			   size_t *guardsize)
 {
-  *guardsize = attr->guardsize;
+  *guardsize = attr->__guardsize;
   return 0;
 }
diff --git a/sysdeps/generic/pt-attr-getinheritsched.c b/sysdeps/generic/pt-attr-getinheritsched.c
index 7f1f601..5d5fc84 100644
--- a/sysdeps/generic/pt-attr-getinheritsched.c
+++ b/sysdeps/generic/pt-attr-getinheritsched.c
@@ -24,7 +24,7 @@ int
 __pthread_attr_getinheritsched (const pthread_attr_t *attr,
 			      int *inheritsched)
 {
-  *inheritsched = attr->inheritsched;
+  *inheritsched = attr->__inheritsched;
   return 0;
 }
 
diff --git a/sysdeps/generic/pt-attr-getschedparam.c b/sysdeps/generic/pt-attr-getschedparam.c
index 4519b69..85e07a1 100644
--- a/sysdeps/generic/pt-attr-getschedparam.c
+++ b/sysdeps/generic/pt-attr-getschedparam.c
@@ -27,7 +27,7 @@ int
 __pthread_attr_getschedparam (const pthread_attr_t *attr,
 			    struct sched_param *param)
 {
-  memcpy (param, &attr->schedparam, sizeof *param);
+  memcpy (param, &attr->__schedparam, sizeof *param);
   return 0;
 }
 
diff --git a/sysdeps/generic/pt-attr-getschedpolicy.c b/sysdeps/generic/pt-attr-getschedpolicy.c
index 0980bdd..caf8a7b 100644
--- a/sysdeps/generic/pt-attr-getschedpolicy.c
+++ b/sysdeps/generic/pt-attr-getschedpolicy.c
@@ -24,7 +24,7 @@ int
 __pthread_attr_getschedpolicy (const pthread_attr_t *attr,
 			     int *policy)
 {
-  *policy = attr->schedpolicy;
+  *policy = attr->__schedpolicy;
   return 0;
 }
 
diff --git a/sysdeps/generic/pt-attr-getscope.c b/sysdeps/generic/pt-attr-getscope.c
index 46eb604..5e0c1a0 100644
--- a/sysdeps/generic/pt-attr-getscope.c
+++ b/sysdeps/generic/pt-attr-getscope.c
@@ -24,7 +24,7 @@ int
 __pthread_attr_getscope (const pthread_attr_t *attr,
 		       int *contentionscope)
 {
-  *contentionscope = attr->contentionscope;
+  *contentionscope = attr->__contentionscope;
   return 0;
 }
 
diff --git a/sysdeps/generic/pt-attr-getstackaddr.c b/sysdeps/generic/pt-attr-getstackaddr.c
index d43eeff..0360701 100644
--- a/sysdeps/generic/pt-attr-getstackaddr.c
+++ b/sysdeps/generic/pt-attr-getstackaddr.c
@@ -24,6 +24,6 @@ int
 pthread_attr_getstackaddr (const pthread_attr_t *attr,
 			   void **stackaddr)
 {
-  *stackaddr = attr->stackaddr;
+  *stackaddr = attr->__stackaddr;
   return 0;
 }
diff --git a/sysdeps/generic/pt-attr-getstacksize.c b/sysdeps/generic/pt-attr-getstacksize.c
index c1bc661..428aaa3 100644
--- a/sysdeps/generic/pt-attr-getstacksize.c
+++ b/sysdeps/generic/pt-attr-getstacksize.c
@@ -24,6 +24,6 @@ int
 pthread_attr_getstacksize (const pthread_attr_t *attr,
 			   size_t *stacksize)
 {
-  *stacksize = attr->stacksize;
+  *stacksize = attr->__stacksize;
   return 0;
 }
diff --git a/sysdeps/generic/pt-attr-setdetachstate.c b/sysdeps/generic/pt-attr-setdetachstate.c
index abd6bbb..cf3ebea 100644
--- a/sysdeps/generic/pt-attr-setdetachstate.c
+++ b/sysdeps/generic/pt-attr-setdetachstate.c
@@ -28,7 +28,7 @@ __pthread_attr_setdetachstate (pthread_attr_t *attr,
     {
     case PTHREAD_CREATE_DETACHED:
     case PTHREAD_CREATE_JOINABLE:
-      attr->detachstate = detachstate;
+      attr->__detachstate = detachstate;
       break;
     default:
       return EINVAL;
diff --git a/sysdeps/generic/pt-attr-setguardsize.c b/sysdeps/generic/pt-attr-setguardsize.c
index b2ba0f0..ab68dba 100644
--- a/sysdeps/generic/pt-attr-setguardsize.c
+++ b/sysdeps/generic/pt-attr-setguardsize.c
@@ -24,6 +24,6 @@ int
 pthread_attr_setguardsize (pthread_attr_t *attr,
 			   size_t guardsize)
 {
-  attr->guardsize = guardsize;
+  attr->__guardsize = guardsize;
   return 0;
 }
diff --git a/sysdeps/generic/pt-attr-setinheritsched.c b/sysdeps/generic/pt-attr-setinheritsched.c
index 9fdbd4e..e4a7368 100644
--- a/sysdeps/generic/pt-attr-setinheritsched.c
+++ b/sysdeps/generic/pt-attr-setinheritsched.c
@@ -28,7 +28,7 @@ __pthread_attr_setinheritsched (pthread_attr_t *attr,
     {
     case PTHREAD_INHERIT_SCHED:
     case PTHREAD_EXPLICIT_SCHED:
-      attr->inheritsched = inheritsched;
+      attr->__inheritsched = inheritsched;
       break;
     default:
       return EINVAL;
diff --git a/sysdeps/generic/pt-attr-setschedparam.c b/sysdeps/generic/pt-attr-setschedparam.c
index 2fd1d3a..201729e 100644
--- a/sysdeps/generic/pt-attr-setschedparam.c
+++ b/sysdeps/generic/pt-attr-setschedparam.c
@@ -27,10 +27,10 @@ int
 __pthread_attr_setschedparam (pthread_attr_t *attr,
 			    const struct sched_param *param)
 {
-  if (memcmp (param, &__pthread_default_attr.schedparam,
+  if (memcmp (param, &__pthread_default_attr.__schedparam,
 	      sizeof *param) == 0)
     {
-      memcpy (&attr->schedparam, param, sizeof *param);
+      memcpy (&attr->__schedparam, param, sizeof *param);
       return 0;
     }
 
diff --git a/sysdeps/generic/pt-attr-setschedpolicy.c b/sysdeps/generic/pt-attr-setschedpolicy.c
index 04e93c9..070948c 100644
--- a/sysdeps/generic/pt-attr-setschedpolicy.c
+++ b/sysdeps/generic/pt-attr-setschedpolicy.c
@@ -27,7 +27,7 @@ __pthread_attr_setschedpolicy (pthread_attr_t *attr,
   switch (policy)
     {
     case SCHED_OTHER:
-      attr->schedpolicy = policy;
+      attr->__schedpolicy = policy;
       break;
 
     case SCHED_FIFO:
diff --git a/sysdeps/generic/pt-attr-setscope.c b/sysdeps/generic/pt-attr-setscope.c
index d86d7b5..09c5d84 100644
--- a/sysdeps/generic/pt-attr-setscope.c
+++ b/sysdeps/generic/pt-attr-setscope.c
@@ -24,9 +24,9 @@ int
 __pthread_attr_setscope (pthread_attr_t *attr,
 		       int contentionscope)
 {
-  if (contentionscope == __pthread_default_attr.contentionscope)
+  if (contentionscope == __pthread_default_attr.__contentionscope)
     {
-      attr->contentionscope = contentionscope;
+      attr->__contentionscope = contentionscope;
       return 0;
     }
 
diff --git a/sysdeps/generic/pt-attr-setstackaddr.c b/sysdeps/generic/pt-attr-setstackaddr.c
index 431f2d0..2e292e5 100644
--- a/sysdeps/generic/pt-attr-setstackaddr.c
+++ b/sysdeps/generic/pt-attr-setstackaddr.c
@@ -24,6 +24,6 @@ int
 pthread_attr_setstackaddr (pthread_attr_t *attr,
 			   void *stackaddr)
 {
-  attr->stackaddr = stackaddr;
+  attr->__stackaddr = stackaddr;
   return 0;
 }
diff --git a/sysdeps/generic/pt-attr-setstacksize.c b/sysdeps/generic/pt-attr-setstacksize.c
index 00d9675..da754d7 100644
--- a/sysdeps/generic/pt-attr-setstacksize.c
+++ b/sysdeps/generic/pt-attr-setstacksize.c
@@ -24,7 +24,7 @@ int
 pthread_attr_setstacksize (pthread_attr_t *attr,
 			   size_t stacksize)
 {
-  attr->stacksize = stacksize;
+  attr->__stacksize = stacksize;
 
   return 0;
 }
diff --git a/sysdeps/generic/pt-attr.c b/sysdeps/generic/pt-attr.c
index 225f18b..064b6ea 100644
--- a/sysdeps/generic/pt-attr.c
+++ b/sysdeps/generic/pt-attr.c
@@ -26,16 +26,16 @@
 
 const struct __pthread_attr __pthread_default_attr =
 {
-  schedparam: { sched_priority: 0 },
-  stacksize: 0,
-  stackaddr: NULL,
+  __schedparam: { sched_priority: 0 },
+  __stacksize: 0,
+  __stackaddr: NULL,
 #ifdef PAGESIZE
-  guardsize: PAGESIZE,
+  __guardsize: PAGESIZE,
 #else
-  guardsize: 1,
+  __guardsize: 1,
 #endif /* PAGESIZE */
-  detachstate: PTHREAD_CREATE_JOINABLE,
-  inheritsched: PTHREAD_EXPLICIT_SCHED,
-  contentionscope: PTHREAD_SCOPE_SYSTEM,
-  schedpolicy: SCHED_OTHER
+  __detachstate: PTHREAD_CREATE_JOINABLE,
+  __inheritsched: PTHREAD_EXPLICIT_SCHED,
+  __contentionscope: PTHREAD_SCOPE_SYSTEM,
+  __schedpolicy: SCHED_OTHER
 };
diff --git a/sysdeps/generic/pt-barrier-init.c b/sysdeps/generic/pt-barrier-init.c
index c42b3bb..056dd1f 100644
--- a/sysdeps/generic/pt-barrier-init.c
+++ b/sysdeps/generic/pt-barrier-init.c
@@ -33,9 +33,9 @@ pthread_barrier_init (pthread_barrier_t *barrier,
 
   memset (barrier, 0, sizeof *barrier);
 
-  barrier->lock = PTHREAD_SPINLOCK_INITIALIZER;
-  barrier->pending = count;
-  barrier->count = count;
+  barrier->__lock = PTHREAD_SPINLOCK_INITIALIZER;
+  barrier->__pending = count;
+  barrier->__count = count;
 
   if (! attr
       || memcmp (attr, &__pthread_default_barrierattr, sizeof (*attr) == 0))
@@ -44,10 +44,10 @@ pthread_barrier_init (pthread_barrier_t *barrier,
 
   /* Non-default attributes.  */
 
-  barrier->attr = malloc (sizeof *attr);
-  if (! barrier->attr)
+  barrier->__attr = malloc (sizeof *attr);
+  if (! barrier->__attr)
     return ENOMEM;
 
-  *barrier->attr = *attr;
+  *barrier->__attr = *attr;
   return 0;
 }
diff --git a/sysdeps/generic/pt-barrier-wait.c b/sysdeps/generic/pt-barrier-wait.c
index 42fbdb0..2dd1cc3 100644
--- a/sysdeps/generic/pt-barrier-wait.c
+++ b/sysdeps/generic/pt-barrier-wait.c
@@ -25,28 +25,28 @@
 int
 pthread_barrier_wait (pthread_barrier_t *barrier)
 {
-  __pthread_spin_lock (&barrier->lock);
-  if (-- barrier->pending == 0)
+  __pthread_spin_lock (&barrier->__lock);
+  if (-- barrier->__pending == 0)
     {
-      barrier->pending = barrier->count;
+      barrier->__pending = barrier->__count;
 
-      if (barrier->count > 1)
+      if (barrier->__count > 1)
 	{
 	  struct __pthread *wakeup;
 	  unsigned n = 0;
 
-	  __pthread_queue_iterate (barrier->queue, wakeup)
+	  __pthread_queue_iterate (barrier->__queue, wakeup)
 	    n ++;
 
 	  {
 	    struct __pthread *wakeups[n];
 	    unsigned i = 0;
 
-	    __pthread_dequeuing_iterate (barrier->queue, wakeup)
+	    __pthread_dequeuing_iterate (barrier->__queue, wakeup)
 	      wakeups[i ++] = wakeup;
 
-	    barrier->queue = NULL;
-	    __pthread_spin_unlock (&barrier->lock);
+	    barrier->__queue = NULL;
+	    __pthread_spin_unlock (&barrier->__lock);
 
 	    for (i = 0; i < n; i ++)
 	      __pthread_wakeup (wakeups[i]);
@@ -60,8 +60,8 @@ pthread_barrier_wait (pthread_barrier_t *barrier)
       struct __pthread *self = _pthread_self ();
 
       /* Add ourselves to the list of waiters.  */
-      __pthread_enqueue (&barrier->queue, self);
-      __pthread_spin_unlock (&barrier->lock);
+      __pthread_enqueue (&barrier->__queue, self);
+      __pthread_spin_unlock (&barrier->__lock);
 
       __pthread_block (self);
       return 0;
diff --git a/sysdeps/generic/pt-barrier.c b/sysdeps/generic/pt-barrier.c
index d772719..28a2ef1 100644
--- a/sysdeps/generic/pt-barrier.c
+++ b/sysdeps/generic/pt-barrier.c
@@ -22,5 +22,5 @@
 
 const struct __pthread_barrierattr __pthread_default_barrierattr =
 {
-  pshared: PTHREAD_PROCESS_PRIVATE
+  __pshared: PTHREAD_PROCESS_PRIVATE
 };
diff --git a/sysdeps/generic/pt-barrierattr-getpshared.c b/sysdeps/generic/pt-barrierattr-getpshared.c
index ed2cdd2..f87f2ae 100644
--- a/sysdeps/generic/pt-barrierattr-getpshared.c
+++ b/sysdeps/generic/pt-barrierattr-getpshared.c
@@ -24,6 +24,6 @@ int
 pthread_barrierattr_getpshared (const pthread_barrierattr_t *attr,
 				int *pshared)
 {
-  *pshared = attr->pshared;
+  *pshared = attr->__pshared;
   return 0;
 }
diff --git a/sysdeps/generic/pt-barrierattr-setpshared.c b/sysdeps/generic/pt-barrierattr-setpshared.c
index 84ef2df..ecad630 100644
--- a/sysdeps/generic/pt-barrierattr-setpshared.c
+++ b/sysdeps/generic/pt-barrierattr-setpshared.c
@@ -27,7 +27,7 @@ pthread_barrierattr_setpshared (pthread_barrierattr_t *attr,
   switch (pshared)
     {
     case PTHREAD_PROCESS_PRIVATE:
-      attr->pshared = pshared;
+      attr->__pshared = pshared;
       return 0;
 
     case PTHREAD_PROCESS_SHARED:
diff --git a/sysdeps/generic/pt-cond-timedwait.c b/sysdeps/generic/pt-cond-timedwait.c
index 978b0f4..e44d9ad 100644
--- a/sysdeps/generic/pt-cond-timedwait.c
+++ b/sysdeps/generic/pt-cond-timedwait.c
@@ -72,7 +72,7 @@ __pthread_cond_timedwait_internal (pthread_cond_t *cond,
 {
   error_t err;
   int cancelled, oldtype, drain;
-  clockid_t clock_id = __pthread_default_condattr.clock;
+  clockid_t clock_id = __pthread_default_condattr.__clock;
 
   if (abstime && (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000))
     return EINVAL;
@@ -110,7 +110,7 @@ __pthread_cond_timedwait_internal (pthread_cond_t *cond,
       __pthread_spin_lock (&cond->__lock);
       __pthread_enqueue (&cond->__queue, self);
       if (cond->__attr)
-	clock_id = cond->__attr->clock;
+	clock_id = cond->__attr->__clock;
       __pthread_spin_unlock (&cond->__lock);
     }
   __pthread_mutex_unlock (&self->cancel_lock);
diff --git a/sysdeps/generic/pt-cond.c b/sysdeps/generic/pt-cond.c
index 033e767..05f0520 100644
--- a/sysdeps/generic/pt-cond.c
+++ b/sysdeps/generic/pt-cond.c
@@ -24,6 +24,6 @@
 
 const struct __pthread_condattr __pthread_default_condattr =
 {
-  pshared: PTHREAD_PROCESS_PRIVATE,
-  clock: CLOCK_REALTIME
+  __pshared: PTHREAD_PROCESS_PRIVATE,
+  __clock: CLOCK_REALTIME
 };
diff --git a/sysdeps/generic/pt-condattr-getclock.c b/sysdeps/generic/pt-condattr-getclock.c
index 5b9f889..4885b13 100644
--- a/sysdeps/generic/pt-condattr-getclock.c
+++ b/sysdeps/generic/pt-condattr-getclock.c
@@ -26,6 +26,6 @@ int
 pthread_condattr_getclock (const pthread_condattr_t *attr,
 			   clockid_t *clock)
 {
-  *clock = attr->clock;
+  *clock = attr->__clock;
   return 0;
 }
diff --git a/sysdeps/generic/pt-condattr-getpshared.c b/sysdeps/generic/pt-condattr-getpshared.c
index c072a50..a27dbc4 100644
--- a/sysdeps/generic/pt-condattr-getpshared.c
+++ b/sysdeps/generic/pt-condattr-getpshared.c
@@ -24,6 +24,6 @@ int
 pthread_condattr_getpshared (const pthread_condattr_t *attr,
 			     int *pshared)
 {
-  *pshared = attr->pshared;
+  *pshared = attr->__pshared;
   return 0;
 }
diff --git a/sysdeps/generic/pt-condattr-setclock.c b/sysdeps/generic/pt-condattr-setclock.c
index c8ac4ce..ad28834 100644
--- a/sysdeps/generic/pt-condattr-setclock.c
+++ b/sysdeps/generic/pt-condattr-setclock.c
@@ -46,7 +46,7 @@ pthread_condattr_setclock (pthread_condattr_t *attr, clockid_t clock)
   else if (clock != CLOCK_REALTIME)
     return EINVAL;
 
-  attr->clock = clock;
+  attr->__clock = clock;
 
   return 0;
 }
diff --git a/sysdeps/generic/pt-condattr-setpshared.c b/sysdeps/generic/pt-condattr-setpshared.c
index b9f0af8..0316b4d 100644
--- a/sysdeps/generic/pt-condattr-setpshared.c
+++ b/sysdeps/generic/pt-condattr-setpshared.c
@@ -27,7 +27,7 @@ pthread_condattr_setpshared (pthread_condattr_t *attr,
   switch (pshared)
     {
     case PTHREAD_PROCESS_PRIVATE:
-      attr->pshared = pshared;
+      attr->__pshared = pshared;
       return 0;
 
     case PTHREAD_PROCESS_SHARED:
diff --git a/sysdeps/generic/pt-mutex-destroy.c b/sysdeps/generic/pt-mutex-destroy.c
index 3bbc73f..3a3cb89 100644
--- a/sysdeps/generic/pt-mutex-destroy.c
+++ b/sysdeps/generic/pt-mutex-destroy.c
@@ -26,12 +26,12 @@
 int
 _pthread_mutex_destroy (pthread_mutex_t *mutex)
 {
-  if (mutex->attr == __PTHREAD_ERRORCHECK_MUTEXATTR
-   || mutex->attr == __PTHREAD_RECURSIVE_MUTEXATTR)
+  if (mutex->__attr == __PTHREAD_ERRORCHECK_MUTEXATTR
+   || mutex->__attr == __PTHREAD_RECURSIVE_MUTEXATTR)
     /* Static attributes.  */
     ;
   else
-    free (mutex->attr);
+    free (mutex->__attr);
 
   return 0;
 }
diff --git a/sysdeps/generic/pt-mutex-init.c b/sysdeps/generic/pt-mutex-init.c
index 2f96028..7f21511 100644
--- a/sysdeps/generic/pt-mutex-init.c
+++ b/sysdeps/generic/pt-mutex-init.c
@@ -35,15 +35,15 @@ _pthread_mutex_init (pthread_mutex_t *mutex,
     /* The default attributes.  */
     return 0;
 
-  if (! mutex->attr
-      || mutex->attr == __PTHREAD_ERRORCHECK_MUTEXATTR
-      || mutex->attr == __PTHREAD_RECURSIVE_MUTEXATTR)
-    mutex->attr = malloc (sizeof *attr);
+  if (! mutex->__attr
+      || mutex->__attr == __PTHREAD_ERRORCHECK_MUTEXATTR
+      || mutex->__attr == __PTHREAD_RECURSIVE_MUTEXATTR)
+    mutex->__attr = malloc (sizeof *attr);
 
-  if (! mutex->attr)
+  if (! mutex->__attr)
     return ENOMEM;
 
-  *mutex->attr = *attr;
+  *mutex->__attr = *attr;
   return 0;
 }
 
diff --git a/sysdeps/generic/pt-mutex-timedlock.c b/sysdeps/generic/pt-mutex-timedlock.c
index 43e0eda..0f8d447 100644
--- a/sysdeps/generic/pt-mutex-timedlock.c
+++ b/sysdeps/generic/pt-mutex-timedlock.c
@@ -33,7 +33,7 @@ __pthread_mutex_timedlock_internal (struct __pthread_mutex *mutex,
   error_t err;
   int drain;
   struct __pthread *self;
-  const struct __pthread_mutexattr *attr = mutex->attr;
+  const struct __pthread_mutexattr *attr = mutex->__attr;
 
   if (attr == __PTHREAD_ERRORCHECK_MUTEXATTR)
     attr = &__pthread_errorcheck_mutexattr;
@@ -52,22 +52,22 @@ __pthread_mutex_timedlock_internal (struct __pthread_mutex *mutex,
 	   initialized, in particular, before the main thread has a
 	   TCB.  */
 	{
-	  assert (! mutex->owner);
-	  mutex->owner = _pthread_self ();
+	  assert (! mutex->__owner);
+	  mutex->__owner = _pthread_self ();
 	}
 #endif
 #endif
 
       if (attr)
-	switch (attr->mutex_type)
+	switch (attr->__mutex_type)
 	  {
 	  case PTHREAD_MUTEX_NORMAL:
 	    break;
 
 	  case PTHREAD_MUTEX_RECURSIVE:
-	    mutex->locks = 1;
+	    mutex->__locks = 1;
 	  case PTHREAD_MUTEX_ERRORCHECK:
-	    mutex->owner = _pthread_self ();
+	    mutex->__owner = _pthread_self ();
 	    break;
 
 	  default:
@@ -83,18 +83,18 @@ __pthread_mutex_timedlock_internal (struct __pthread_mutex *mutex,
   self = _pthread_self ();
   assert (self);
 
-  if (! attr || attr->mutex_type == PTHREAD_MUTEX_NORMAL)
+  if (! attr || attr->__mutex_type == PTHREAD_MUTEX_NORMAL)
     {
 #if defined(ALWAYS_TRACK_MUTEX_OWNER)
-      assert (mutex->owner != self);
+      assert (mutex->__owner != self);
 #endif
     }
   else
     {
-      switch (attr->mutex_type)
+      switch (attr->__mutex_type)
 	{
 	case PTHREAD_MUTEX_ERRORCHECK:
-	  if (mutex->owner == self)
+	  if (mutex->__owner == self)
 	    {
 	      __pthread_spin_unlock (&mutex->__lock);
 	      return EDEADLK;
@@ -102,9 +102,9 @@ __pthread_mutex_timedlock_internal (struct __pthread_mutex *mutex,
 	  break;
 
 	case PTHREAD_MUTEX_RECURSIVE:
-	  if (mutex->owner == self)
+	  if (mutex->__owner == self)
 	    {
-	      mutex->locks ++;
+	      mutex->__locks ++;
 	      __pthread_spin_unlock (&mutex->__lock);
 	      return 0;
 	    }
@@ -116,9 +116,9 @@ __pthread_mutex_timedlock_internal (struct __pthread_mutex *mutex,
     }
 
 #if !defined(ALWAYS_TRACK_MUTEX_OWNER)
-  if (attr && attr->mutex_type != PTHREAD_MUTEX_NORMAL)
+  if (attr && attr->__mutex_type != PTHREAD_MUTEX_NORMAL)
 #endif
-    assert (mutex->owner);
+    assert (mutex->__owner);
 
   if (abstime && (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000))
     return EINVAL;
@@ -162,23 +162,23 @@ __pthread_mutex_timedlock_internal (struct __pthread_mutex *mutex,
     }
 
 #if !defined(ALWAYS_TRACK_MUTEX_OWNER)
-  if (attr && attr->mutex_type != PTHREAD_MUTEX_NORMAL)
+  if (attr && attr->__mutex_type != PTHREAD_MUTEX_NORMAL)
 #endif
     {
-      assert (mutex->owner == self);
+      assert (mutex->__owner == self);
     }
 
   if (attr)
-    switch (attr->mutex_type)
+    switch (attr->__mutex_type)
       {
       case PTHREAD_MUTEX_NORMAL:
 	break;
 
       case PTHREAD_MUTEX_RECURSIVE:
-	assert (mutex->locks == 0);
-	mutex->locks = 1;
+	assert (mutex->__locks == 0);
+	mutex->__locks = 1;
       case PTHREAD_MUTEX_ERRORCHECK:
-	mutex->owner = self;
+	mutex->__owner = self;
 	break;
 
       default:
diff --git a/sysdeps/generic/pt-mutex-transfer-np.c b/sysdeps/generic/pt-mutex-transfer-np.c
index 967f1c7..21fc040 100644
--- a/sysdeps/generic/pt-mutex-transfer-np.c
+++ b/sysdeps/generic/pt-mutex-transfer-np.c
@@ -26,10 +26,10 @@
 int
 __pthread_mutex_transfer_np (struct __pthread_mutex *mutex, pthread_t tid)
 {
-  assert (mutex->owner == _pthread_self ());
+  assert (mutex->__owner == _pthread_self ());
 
   struct __pthread *thread = __pthread_getid (tid);
-  const struct __pthread_mutexattr *attr = mutex->attr;
+  const struct __pthread_mutexattr *attr = mutex->__attr;
 
   if (! thread)
     return ESRCH;
@@ -42,21 +42,21 @@ __pthread_mutex_transfer_np (struct __pthread_mutex *mutex, pthread_t tid)
   if (attr == __PTHREAD_RECURSIVE_MUTEXATTR)
     attr = &__pthread_recursive_mutexattr;
 
-  if (attr && attr->mutex_type == PTHREAD_MUTEX_ERRORCHECK)
+  if (attr && attr->__mutex_type == PTHREAD_MUTEX_ERRORCHECK)
     {
 
-      if (mutex->owner != _pthread_self ())
+      if (mutex->__owner != _pthread_self ())
 	return EPERM;
 
-      mutex->owner = thread;
+      mutex->__owner = thread;
     }
 
 #ifndef NDEBUG
 # if !defined(ALWAYS_TRACK_MUTEX_OWNER)
-  if (attr && attr->mutex_type != PTHREAD_MUTEX_NORMAL)
+  if (attr && attr->__mutex_type != PTHREAD_MUTEX_NORMAL)
 # endif
     {
-      mutex->owner = thread;
+      mutex->__owner = thread;
     }
 #endif
 
diff --git a/sysdeps/generic/pt-mutex-trylock.c b/sysdeps/generic/pt-mutex-trylock.c
index 7a54cc9..0d5ce7d 100644
--- a/sysdeps/generic/pt-mutex-trylock.c
+++ b/sysdeps/generic/pt-mutex-trylock.c
@@ -29,7 +29,7 @@ __pthread_mutex_trylock (struct __pthread_mutex *mutex)
 {
   int err;
   struct __pthread *self;
-  const struct __pthread_mutexattr *attr = mutex->attr;
+  const struct __pthread_mutexattr *attr = mutex->__attr;
 
   if (attr == __PTHREAD_ERRORCHECK_MUTEXATTR)
     attr = &__pthread_errorcheck_mutexattr;
@@ -48,22 +48,22 @@ __pthread_mutex_trylock (struct __pthread_mutex *mutex)
 	   initialized, in particular, before the main thread has a
 	   TCB.  */
 	{
-	  assert (! mutex->owner);
-	  mutex->owner = _pthread_self ();
+	  assert (! mutex->__owner);
+	  mutex->__owner = _pthread_self ();
 	}
 #endif
 #endif
 
       if (attr)
-	switch (attr->mutex_type)
+	switch (attr->__mutex_type)
 	  {
 	  case PTHREAD_MUTEX_NORMAL:
 	    break;
 
 	  case PTHREAD_MUTEX_RECURSIVE:
-	    mutex->locks = 1;
+	    mutex->__locks = 1;
 	  case PTHREAD_MUTEX_ERRORCHECK:
-	    mutex->owner = _pthread_self ();
+	    mutex->__owner = _pthread_self ();
 	    break;
 
 	  default:
@@ -79,7 +79,7 @@ __pthread_mutex_trylock (struct __pthread_mutex *mutex)
   if (attr)
     {
       self = _pthread_self ();
-      switch (attr->mutex_type)
+      switch (attr->__mutex_type)
 	{
 	case PTHREAD_MUTEX_NORMAL:
 	  break;
@@ -91,9 +91,9 @@ __pthread_mutex_trylock (struct __pthread_mutex *mutex)
 	  break;
 
 	case PTHREAD_MUTEX_RECURSIVE:
-	  if (mutex->owner == self)
+	  if (mutex->__owner == self)
 	    {
-	      mutex->locks ++;
+	      mutex->__locks ++;
 	      err = 0;
 	    }
 	  break;
diff --git a/sysdeps/generic/pt-mutex-unlock.c b/sysdeps/generic/pt-mutex-unlock.c
index 09d70f8..08f5975 100644
--- a/sysdeps/generic/pt-mutex-unlock.c
+++ b/sysdeps/generic/pt-mutex-unlock.c
@@ -28,7 +28,7 @@ int
 __pthread_mutex_unlock (pthread_mutex_t *mutex)
 {
   struct __pthread *wakeup;
-  const struct __pthread_mutexattr *attr = mutex->attr;
+  const struct __pthread_mutexattr *attr = mutex->__attr;
 
   if (attr == __PTHREAD_ERRORCHECK_MUTEXATTR)
     attr = &__pthread_errorcheck_mutexattr;
@@ -37,38 +37,38 @@ __pthread_mutex_unlock (pthread_mutex_t *mutex)
 
   __pthread_spin_lock (&mutex->__lock);
 
-  if (! attr || attr->mutex_type == PTHREAD_MUTEX_NORMAL)
+  if (! attr || attr->__mutex_type == PTHREAD_MUTEX_NORMAL)
     {
 #if defined(ALWAYS_TRACK_MUTEX_OWNER)
 # ifndef NDEBUG
       if (_pthread_self ())
 	{
-	  assert (mutex->owner);
-	  assert (mutex->owner == _pthread_self ());
-	  mutex->owner = NULL;
+	  assert (mutex->__owner);
+	  assert (mutex->__owner == _pthread_self ());
+	  mutex->__owner = NULL;
 	}
 # endif
 #endif
     }
   else
-    switch (attr->mutex_type)
+    switch (attr->__mutex_type)
       {
       case PTHREAD_MUTEX_ERRORCHECK:
       case PTHREAD_MUTEX_RECURSIVE:
-	if (mutex->owner != _pthread_self ())
+	if (mutex->__owner != _pthread_self ())
 	  {
 	    __pthread_spin_unlock (&mutex->__lock);
 	    return EPERM;
 	  }
 
-	if (attr->mutex_type == PTHREAD_MUTEX_RECURSIVE)
-	  if (--mutex->locks > 0)
+	if (attr->__mutex_type == PTHREAD_MUTEX_RECURSIVE)
+	  if (--mutex->__locks > 0)
 	    {
 	      __pthread_spin_unlock (&mutex->__lock);
 	      return 0;
 	    }
 
-	mutex->owner = 0;
+	mutex->__owner = 0;
 	break;
 
       default:
@@ -88,10 +88,10 @@ __pthread_mutex_unlock (pthread_mutex_t *mutex)
 
 #ifndef NDEBUG
 # if !defined (ALWAYS_TRACK_MUTEX_OWNER)
-  if (attr && attr->mutex_type != PTHREAD_MUTEX_NORMAL)
+  if (attr && attr->__mutex_type != PTHREAD_MUTEX_NORMAL)
 # endif
     {
-      mutex->owner = wakeup;
+      mutex->__owner = wakeup;
     }
 #endif
 
diff --git a/sysdeps/generic/pt-mutexattr-getprotocol.c b/sysdeps/generic/pt-mutexattr-getprotocol.c
index d75021a..c53d755 100644
--- a/sysdeps/generic/pt-mutexattr-getprotocol.c
+++ b/sysdeps/generic/pt-mutexattr-getprotocol.c
@@ -24,6 +24,6 @@ int
 pthread_mutexattr_getprotocol (const pthread_mutexattr_t *attr,
 			       int *protocol)
 {
-  *protocol = attr->protocol;
+  *protocol = attr->__protocol;
   return 0;
 }
diff --git a/sysdeps/generic/pt-mutexattr-getpshared.c b/sysdeps/generic/pt-mutexattr-getpshared.c
index 0dad13b..494b2de 100644
--- a/sysdeps/generic/pt-mutexattr-getpshared.c
+++ b/sysdeps/generic/pt-mutexattr-getpshared.c
@@ -24,6 +24,6 @@ int
 pthread_mutexattr_getpshared (const pthread_mutexattr_t *attr,
 			      int *pshared)
 {
-  *pshared = attr->pshared;
+  *pshared = attr->__pshared;
   return 0;
 }
diff --git a/sysdeps/generic/pt-mutexattr-gettype.c b/sysdeps/generic/pt-mutexattr-gettype.c
index ff2caea..28fee9a 100644
--- a/sysdeps/generic/pt-mutexattr-gettype.c
+++ b/sysdeps/generic/pt-mutexattr-gettype.c
@@ -23,6 +23,6 @@
 int
 pthread_mutexattr_gettype (const pthread_mutexattr_t *attr, int *type)
 {
-  *type = attr->mutex_type;
+  *type = attr->__mutex_type;
   return 0;
 }
diff --git a/sysdeps/generic/pt-mutexattr-setprotocol.c b/sysdeps/generic/pt-mutexattr-setprotocol.c
index 9a0d1b1..e11dc35 100644
--- a/sysdeps/generic/pt-mutexattr-setprotocol.c
+++ b/sysdeps/generic/pt-mutexattr-setprotocol.c
@@ -24,9 +24,9 @@ int
 pthread_mutexattr_setprotocol (pthread_mutexattr_t *attr,
 			       int protocol)
 {
-  if (protocol == __pthread_default_mutexattr.protocol)
+  if (protocol == __pthread_default_mutexattr.__protocol)
     {
-      attr->protocol = protocol;
+      attr->__protocol = protocol;
       return 0;
     }
 
diff --git a/sysdeps/generic/pt-mutexattr-setpshared.c b/sysdeps/generic/pt-mutexattr-setpshared.c
index bcbc4d9..b7dc1f0 100644
--- a/sysdeps/generic/pt-mutexattr-setpshared.c
+++ b/sysdeps/generic/pt-mutexattr-setpshared.c
@@ -27,7 +27,7 @@ pthread_mutexattr_setpshared (pthread_mutexattr_t *attr,
   switch (pshared)
     {
     case PTHREAD_PROCESS_PRIVATE:
-      attr->pshared = pshared;
+      attr->__pshared = pshared;
       return 0;
 
     case PTHREAD_PROCESS_SHARED:
diff --git a/sysdeps/generic/pt-mutexattr-settype.c b/sysdeps/generic/pt-mutexattr-settype.c
index e7ae213..5c46010 100644
--- a/sysdeps/generic/pt-mutexattr-settype.c
+++ b/sysdeps/generic/pt-mutexattr-settype.c
@@ -28,7 +28,7 @@ pthread_mutexattr_settype (pthread_mutexattr_t *attr, int type)
     case PTHREAD_MUTEX_NORMAL:
     case PTHREAD_MUTEX_ERRORCHECK:
     case PTHREAD_MUTEX_RECURSIVE:
-      attr->mutex_type = type;
+      attr->__mutex_type = type;
       return 0;
 
     default:
diff --git a/sysdeps/generic/pt-mutexattr.c b/sysdeps/generic/pt-mutexattr.c
index 5ebde6e..f9282af 100644
--- a/sysdeps/generic/pt-mutexattr.c
+++ b/sysdeps/generic/pt-mutexattr.c
@@ -22,24 +22,24 @@
 
 const struct __pthread_mutexattr __pthread_default_mutexattr =
 {
-  prioceiling: 0,
-  protocol: PTHREAD_PRIO_NONE,
-  pshared: PTHREAD_PROCESS_PRIVATE,
-  mutex_type: PTHREAD_MUTEX_DEFAULT
+  __prioceiling: 0,
+  __protocol: PTHREAD_PRIO_NONE,
+  __pshared: PTHREAD_PROCESS_PRIVATE,
+  __mutex_type: PTHREAD_MUTEX_DEFAULT
 };
 
 const struct __pthread_mutexattr __pthread_errorcheck_mutexattr =
 {
-  prioceiling: 0,
-  protocol: PTHREAD_PRIO_NONE,
-  pshared: PTHREAD_PROCESS_PRIVATE,
-  mutex_type: PTHREAD_MUTEX_ERRORCHECK
+  __prioceiling: 0,
+  __protocol: PTHREAD_PRIO_NONE,
+  __pshared: PTHREAD_PROCESS_PRIVATE,
+  __mutex_type: PTHREAD_MUTEX_ERRORCHECK
 };
 
 const struct __pthread_mutexattr __pthread_recursive_mutexattr =
 {
-  prioceiling: 0,
-  protocol: PTHREAD_PRIO_NONE,
-  pshared: PTHREAD_PROCESS_PRIVATE,
-  mutex_type: PTHREAD_MUTEX_RECURSIVE
+  __prioceiling: 0,
+  __protocol: PTHREAD_PRIO_NONE,
+  __pshared: PTHREAD_PROCESS_PRIVATE,
+  __mutex_type: PTHREAD_MUTEX_RECURSIVE
 };
diff --git a/sysdeps/generic/pt-once.c b/sysdeps/generic/pt-once.c
index d9f4733..21f097d 100644
--- a/sysdeps/generic/pt-once.c
+++ b/sysdeps/generic/pt-once.c
@@ -25,18 +25,18 @@
 int
 __pthread_once (pthread_once_t *once_control, void (*init_routine) (void))
 {
-  if (once_control->run == 0)
+  if (once_control->__run == 0)
     {
-      __pthread_spin_lock (&once_control->lock);
+      __pthread_spin_lock (&once_control->__lock);
 
-      if (once_control->run == 0)
+      if (once_control->__run == 0)
 	{
 	  init_routine ();
 	  __memory_barrier ();
-	  once_control->run = 1;
+	  once_control->__run = 1;
 	}
 
-      __pthread_spin_unlock (&once_control->lock);
+      __pthread_spin_unlock (&once_control->__lock);
     }
 
   return 0;
diff --git a/sysdeps/generic/pt-rwlock-attr.c b/sysdeps/generic/pt-rwlock-attr.c
index 1587fee..8de96f1 100644
--- a/sysdeps/generic/pt-rwlock-attr.c
+++ b/sysdeps/generic/pt-rwlock-attr.c
@@ -22,5 +22,5 @@
 
 const struct __pthread_rwlockattr __pthread_default_rwlockattr =
 {
-  pshared: PTHREAD_PROCESS_PRIVATE
+  __pshared: PTHREAD_PROCESS_PRIVATE
 };
diff --git a/sysdeps/generic/pt-rwlock-timedrdlock.c b/sysdeps/generic/pt-rwlock-timedrdlock.c
index a81ca71..69bc757 100644
--- a/sysdeps/generic/pt-rwlock-timedrdlock.c
+++ b/sysdeps/generic/pt-rwlock-timedrdlock.c
@@ -37,21 +37,21 @@ __pthread_rwlock_timedrdlock_internal (struct __pthread_rwlock *rwlock,
   if (__pthread_spin_trylock (&rwlock->__held) == 0)
     /* Successfully acquired the lock.  */
     {
-      assert (rwlock->readerqueue == 0);
-      assert (rwlock->writerqueue == 0);
-      assert (rwlock->readers == 0);
+      assert (rwlock->__readerqueue == 0);
+      assert (rwlock->__writerqueue == 0);
+      assert (rwlock->__readers == 0);
 
-      rwlock->readers = 1;
+      rwlock->__readers = 1;
       __pthread_spin_unlock (&rwlock->__lock);
       return 0;
     }
   else
     /* Lock is held, but is held by a reader?  */
-    if (rwlock->readers > 0)
+    if (rwlock->__readers > 0)
       /* Just add ourself to number of readers.  */
       {
-	assert (rwlock->readerqueue == 0);
-	rwlock->readers ++;
+	assert (rwlock->__readerqueue == 0);
+	rwlock->__readers ++;
 	__pthread_spin_unlock (&rwlock->__lock);
 	return 0;
       }
@@ -59,7 +59,7 @@ __pthread_rwlock_timedrdlock_internal (struct __pthread_rwlock *rwlock,
   /* The lock is busy.  */
 
   /* Better be blocked by a writer.  */
-  assert (rwlock->readers == 0);
+  assert (rwlock->__readers == 0);
 
   if (abstime && (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000))
     return EINVAL;
@@ -67,7 +67,7 @@ __pthread_rwlock_timedrdlock_internal (struct __pthread_rwlock *rwlock,
   self = _pthread_self ();
 
   /* Add ourself to the queue.  */
-  __pthread_enqueue (&rwlock->readerqueue, self);
+  __pthread_enqueue (&rwlock->__readerqueue, self);
   __pthread_spin_unlock (&rwlock->__lock);
 
   /* Block the thread.  */
@@ -107,7 +107,7 @@ __pthread_rwlock_timedrdlock_internal (struct __pthread_rwlock *rwlock,
   /* The reader count has already been increment by whoever woke us
      up.  */
 
-  assert (rwlock->readers > 0);
+  assert (rwlock->__readers > 0);
 
   return 0;
 }
diff --git a/sysdeps/generic/pt-rwlock-timedwrlock.c b/sysdeps/generic/pt-rwlock-timedwrlock.c
index e47e936..be25629 100644
--- a/sysdeps/generic/pt-rwlock-timedwrlock.c
+++ b/sysdeps/generic/pt-rwlock-timedwrlock.c
@@ -37,9 +37,9 @@ __pthread_rwlock_timedwrlock_internal (struct __pthread_rwlock *rwlock,
   if (__pthread_spin_trylock (&rwlock->__held) == 0)
     /* Successfully acquired the lock.  */
     {
-      assert (rwlock->readerqueue == 0);
-      assert (rwlock->writerqueue == 0);
-      assert (rwlock->readers == 0);
+      assert (rwlock->__readerqueue == 0);
+      assert (rwlock->__writerqueue == 0);
+      assert (rwlock->__readers == 0);
 
       __pthread_spin_unlock (&rwlock->__lock);
       return 0;
@@ -53,7 +53,7 @@ __pthread_rwlock_timedwrlock_internal (struct __pthread_rwlock *rwlock,
   self = _pthread_self ();
 
   /* Add ourselves to the queue.  */
-  __pthread_enqueue (&rwlock->writerqueue, self);
+  __pthread_enqueue (&rwlock->__writerqueue, self);
   __pthread_spin_unlock (&rwlock->__lock);
 
   /* Block the thread.  */
@@ -90,7 +90,7 @@ __pthread_rwlock_timedwrlock_internal (struct __pthread_rwlock *rwlock,
       return err;
     }
 
-  assert (rwlock->readers == 0);
+  assert (rwlock->__readers == 0);
 
   return 0;
 }
diff --git a/sysdeps/generic/pt-rwlock-tryrdlock.c b/sysdeps/generic/pt-rwlock-tryrdlock.c
index 2419efb..30cb6cf 100644
--- a/sysdeps/generic/pt-rwlock-tryrdlock.c
+++ b/sysdeps/generic/pt-rwlock-tryrdlock.c
@@ -30,20 +30,20 @@ pthread_rwlock_tryrdlock (struct __pthread_rwlock *rwlock)
   if (__pthread_spin_trylock (&rwlock->__held) == 0)
     /* Successfully acquired the lock.  */
     {
-      assert (rwlock->readerqueue == 0);
-      assert (rwlock->writerqueue == 0);
-      assert (rwlock->readers == 0);
+      assert (rwlock->__readerqueue == 0);
+      assert (rwlock->__writerqueue == 0);
+      assert (rwlock->__readers == 0);
 
-      rwlock->readers = 1;
+      rwlock->__readers = 1;
       __pthread_spin_unlock (&rwlock->__lock);
       return 0;
     }
   else
     /* Lock is held, but is held by a reader?  */
-    if (rwlock->readers > 0)
+    if (rwlock->__readers > 0)
       {
-	assert (rwlock->readerqueue == 0);
-	rwlock->readers ++;
+	assert (rwlock->__readerqueue == 0);
+	rwlock->__readers ++;
 	__pthread_spin_unlock (&rwlock->__lock);
 	return 0;
       }
diff --git a/sysdeps/generic/pt-rwlock-trywrlock.c b/sysdeps/generic/pt-rwlock-trywrlock.c
index 6b9c5b5..af8f911 100644
--- a/sysdeps/generic/pt-rwlock-trywrlock.c
+++ b/sysdeps/generic/pt-rwlock-trywrlock.c
@@ -30,9 +30,9 @@ pthread_rwlock_trywrlock (struct __pthread_rwlock *rwlock)
   if (__pthread_spin_trylock (&rwlock->__held) == 0)
     /* Successfully acquired the lock.  */
     {
-      assert (rwlock->readerqueue == 0);
-      assert (rwlock->writerqueue == 0);
-      assert (rwlock->readers == 0);
+      assert (rwlock->__readerqueue == 0);
+      assert (rwlock->__writerqueue == 0);
+      assert (rwlock->__readers == 0);
 
       __pthread_spin_unlock (&rwlock->__lock);
       return 0;
diff --git a/sysdeps/generic/pt-rwlock-unlock.c b/sysdeps/generic/pt-rwlock-unlock.c
index b45ad23..d538544 100644
--- a/sysdeps/generic/pt-rwlock-unlock.c
+++ b/sysdeps/generic/pt-rwlock-unlock.c
@@ -33,25 +33,25 @@ __pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
 
   assert (__pthread_spin_trylock (&rwlock->__held) == EBUSY);
 
-  if (rwlock->readers > 1)
+  if (rwlock->__readers > 1)
     /* There are other readers.  */
     {
-      rwlock->readers --;
+      rwlock->__readers --;
       __pthread_spin_unlock (&rwlock->__lock);
       return 0;
     }
 
-  if (rwlock->readers == 1)
+  if (rwlock->__readers == 1)
     /* Last reader.  */
-    rwlock->readers = 0;
+    rwlock->__readers = 0;
       
 
   /* Wake someone else up.  Try the writer queue first, then the
      reader queue if that is empty.  */
 
-  if (rwlock->writerqueue)
+  if (rwlock->__writerqueue)
     {
-      wakeup = rwlock->writerqueue;
+      wakeup = rwlock->__writerqueue;
       __pthread_dequeue (wakeup);
 
       /* We do not unlock RWLOCK->held: we are transferring the ownership
@@ -63,22 +63,22 @@ __pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
       return 0;
     }
 
-  if (rwlock->readerqueue)
+  if (rwlock->__readerqueue)
     {
       unsigned n = 0;
 
-      __pthread_queue_iterate (rwlock->readerqueue, wakeup)
+      __pthread_queue_iterate (rwlock->__readerqueue, wakeup)
         n ++;
 
       {
 	struct __pthread *wakeups[n];
 	unsigned i = 0;
 
-	__pthread_dequeuing_iterate (rwlock->readerqueue, wakeup)
+	__pthread_dequeuing_iterate (rwlock->__readerqueue, wakeup)
 	    wakeups[i ++] = wakeup;
 
-	rwlock->readers += n;
-	rwlock->readerqueue = 0;
+	rwlock->__readers += n;
+	rwlock->__readerqueue = 0;
 
 	__pthread_spin_unlock (&rwlock->__lock);
 
diff --git a/sysdeps/generic/pt-rwlockattr-getpshared.c b/sysdeps/generic/pt-rwlockattr-getpshared.c
index e8752c0..1565cf1 100644
--- a/sysdeps/generic/pt-rwlockattr-getpshared.c
+++ b/sysdeps/generic/pt-rwlockattr-getpshared.c
@@ -24,6 +24,6 @@ int
 pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *attr,
 			       int *pshared)
 {
-  *pshared = attr->pshared;
+  *pshared = attr->__pshared;
   return 0;
 }
diff --git a/sysdeps/generic/pt-rwlockattr-setpshared.c b/sysdeps/generic/pt-rwlockattr-setpshared.c
index a861d03..71f5c68 100644
--- a/sysdeps/generic/pt-rwlockattr-setpshared.c
+++ b/sysdeps/generic/pt-rwlockattr-setpshared.c
@@ -27,7 +27,7 @@ pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr,
   switch (pshared)
     {
     case PTHREAD_PROCESS_PRIVATE:
-      attr->pshared = pshared;
+      attr->__pshared = pshared;
       return 0;
 
     case PTHREAD_PROCESS_SHARED:
diff --git a/sysdeps/mach/hurd/pt-attr-setstackaddr.c b/sysdeps/mach/hurd/pt-attr-setstackaddr.c
index a0fe536..864835f 100644
--- a/sysdeps/mach/hurd/pt-attr-setstackaddr.c
+++ b/sysdeps/mach/hurd/pt-attr-setstackaddr.c
@@ -24,6 +24,6 @@ int
 pthread_attr_setstackaddr (pthread_attr_t *attr,
 			   void *stackaddr)
 {
-  attr->stackaddr = stackaddr;
+  attr->__stackaddr = stackaddr;
   return 0;
 }
diff --git a/sysdeps/mach/hurd/pt-attr-setstacksize.c b/sysdeps/mach/hurd/pt-attr-setstacksize.c
index 8b90bbd..7757bac 100644
--- a/sysdeps/mach/hurd/pt-attr-setstacksize.c
+++ b/sysdeps/mach/hurd/pt-attr-setstacksize.c
@@ -24,6 +24,6 @@ int
 pthread_attr_setstacksize (pthread_attr_t *attr,
 			   size_t stacksize)
 {
-  attr->stacksize = stacksize;
+  attr->__stacksize = stacksize;
   return 0;
 }
diff --git a/sysdeps/mach/hurd/pt-hurd-cond-timedwait.c b/sysdeps/mach/hurd/pt-hurd-cond-timedwait.c
index 0e11d56..3d1fe53 100644
--- a/sysdeps/mach/hurd/pt-hurd-cond-timedwait.c
+++ b/sysdeps/mach/hurd/pt-hurd-cond-timedwait.c
@@ -46,7 +46,7 @@ __pthread_hurd_cond_timedwait_internal (pthread_cond_t *cond,
   struct __pthread *self = _pthread_self ();
   error_t err = 0;
   int cancel, drain;
-  clockid_t clock_id = __pthread_default_condattr.clock;
+  clockid_t clock_id = __pthread_default_condattr.__clock;
 
   /* This function will be called by hurd_thread_cancel while we are blocked
      We wake up our thread if it's still blocking or about to block, so it will
@@ -91,7 +91,7 @@ __pthread_hurd_cond_timedwait_internal (pthread_cond_t *cond,
          us up.  */
       __pthread_enqueue (&cond->__queue, self);
       if (cond->__attr)
-	clock_id = cond->__attr->clock;
+	clock_id = cond->__attr->__clock;
       /* Tell hurd_thread_cancel how to unblock us.  */
       ss->cancel_hook = &cancel_me;
     }