Adjust for pthread.h and pthreadtypes.h change.
authordrepper <drepper>
Tue, 27 Oct 1998 13:51:54 +0000 (13:51 +0000)
committerdrepper <drepper>
Tue, 27 Oct 1998 13:51:54 +0000 (13:51 +0000)
linuxthreads/attr.c
linuxthreads/cancel.c
linuxthreads/condvar.c
linuxthreads/manager.c
linuxthreads/mutex.c
linuxthreads/pthread.c
linuxthreads/ptlongjmp.c
linuxthreads/rwlock.c
linuxthreads/spinlock.c
linuxthreads/spinlock.h

index 3a19ddc..2a70ebe 100644 (file)
@@ -25,15 +25,15 @@ int __pthread_attr_init_2_1(pthread_attr_t *attr)
 {
   size_t ps = __getpagesize ();
 
-  attr->detachstate = PTHREAD_CREATE_JOINABLE;
-  attr->schedpolicy = SCHED_OTHER;
-  attr->schedparam.sched_priority = 0;
-  attr->inheritsched = PTHREAD_EXPLICIT_SCHED;
-  attr->scope = PTHREAD_SCOPE_SYSTEM;
-  attr->guardsize = ps;
-  attr->stackaddr = NULL;
-  attr->stackaddr_set = 0;
-  attr->stacksize = STACK_SIZE - ps;
+  attr->__detachstate = PTHREAD_CREATE_JOINABLE;
+  attr->__schedpolicy = SCHED_OTHER;
+  attr->__schedparam.sched_priority = 0;
+  attr->__inheritsched = PTHREAD_EXPLICIT_SCHED;
+  attr->__scope = PTHREAD_SCOPE_SYSTEM;
+  attr->__guardsize = ps;
+  attr->__stackaddr = NULL;
+  attr->__stackaddr_set = 0;
+  attr->__stacksize = STACK_SIZE - ps;
   return 0;
 }
 #if defined HAVE_ELF && defined PIC && defined DO_VERSIONING
@@ -41,11 +41,11 @@ default_symbol_version (__pthread_attr_init_2_1, pthread_attr_init, GLIBC_2.1);
 
 int __pthread_attr_init_2_0(pthread_attr_t *attr)
 {
-  attr->detachstate = PTHREAD_CREATE_JOINABLE;
-  attr->schedpolicy = SCHED_OTHER;
-  attr->schedparam.sched_priority = 0;
-  attr->inheritsched = PTHREAD_EXPLICIT_SCHED;
-  attr->scope = PTHREAD_SCOPE_SYSTEM;
+  attr->__detachstate = PTHREAD_CREATE_JOINABLE;
+  attr->__schedpolicy = SCHED_OTHER;
+  attr->__schedparam.sched_priority = 0;
+  attr->__inheritsched = PTHREAD_EXPLICIT_SCHED;
+  attr->__scope = PTHREAD_SCOPE_SYSTEM;
   return 0;
 }
 symbol_version (__pthread_attr_init_2_0, pthread_attr_init, GLIBC_2.0);
@@ -63,32 +63,32 @@ int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
   if (detachstate < PTHREAD_CREATE_JOINABLE ||
       detachstate > PTHREAD_CREATE_DETACHED)
     return EINVAL;
-  attr->detachstate = detachstate;
+  attr->__detachstate = detachstate;
   return 0;
 }
 
 int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate)
 {
-  *detachstate = attr->detachstate;
+  *detachstate = attr->__detachstate;
   return 0;
 }
 
 int pthread_attr_setschedparam(pthread_attr_t *attr,
                                const struct sched_param *param)
 {
-  int max_prio = __sched_get_priority_max(attr->schedpolicy);
-  int min_prio = __sched_get_priority_min(attr->schedpolicy);
+  int max_prio = __sched_get_priority_max(attr->__schedpolicy);
+  int min_prio = __sched_get_priority_min(attr->__schedpolicy);
 
   if (param->sched_priority < min_prio || param->sched_priority > max_prio)
     return EINVAL;
-  memcpy (&attr->schedparam, param, sizeof (struct sched_param));
+  memcpy (&attr->__schedparam, param, sizeof (struct sched_param));
   return 0;
 }
 
 int pthread_attr_getschedparam(const pthread_attr_t *attr,
                                struct sched_param *param)
 {
-  memcpy (param, &attr->schedparam, sizeof (struct sched_param));
+  memcpy (param, &attr->__schedparam, sizeof (struct sched_param));
   return 0;
 }
 
@@ -96,13 +96,13 @@ int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy)
 {
   if (policy != SCHED_OTHER && policy != SCHED_FIFO && policy != SCHED_RR)
     return EINVAL;
-  attr->schedpolicy = policy;
+  attr->__schedpolicy = policy;
   return 0;
 }
 
 int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy)
 {
-  *policy = attr->schedpolicy;
+  *policy = attr->__schedpolicy;
   return 0;
 }
 
@@ -110,13 +110,13 @@ int pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit)
 {
   if (inherit != PTHREAD_INHERIT_SCHED && inherit != PTHREAD_EXPLICIT_SCHED)
     return EINVAL;
-  attr->inheritsched = inherit;
+  attr->__inheritsched = inherit;
   return 0;
 }
 
 int pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inherit)
 {
-  *inherit = attr->inheritsched;
+  *inherit = attr->__inheritsched;
   return 0;
 }
 
@@ -124,7 +124,7 @@ int pthread_attr_setscope(pthread_attr_t *attr, int scope)
 {
   switch (scope) {
   case PTHREAD_SCOPE_SYSTEM:
-    attr->scope = scope;
+    attr->__scope = scope;
     return 0;
   case PTHREAD_SCOPE_PROCESS:
     return ENOTSUP;
@@ -135,7 +135,7 @@ int pthread_attr_setscope(pthread_attr_t *attr, int scope)
 
 int pthread_attr_getscope(const pthread_attr_t *attr, int *scope)
 {
-  *scope = attr->scope;
+  *scope = attr->__scope;
   return 0;
 }
 
@@ -147,9 +147,9 @@ int __pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize)
   guardsize = roundup (guardsize, ps);
 
   /* The guard size must not be larger than the stack itself */
-  if (guardsize >= attr->stacksize) return EINVAL;
+  if (guardsize >= attr->__stacksize) return EINVAL;
 
-  attr->guardsize = guardsize;
+  attr->__guardsize = guardsize;
 
   return 0;
 }
@@ -157,15 +157,15 @@ weak_alias (__pthread_attr_setguardsize, pthread_attr_setguardsize)
 
 int __pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guardsize)
 {
-  *guardsize = attr->guardsize;
+  *guardsize = attr->__guardsize;
   return 0;
 }
 weak_alias (__pthread_attr_getguardsize, pthread_attr_getguardsize)
 
 int __pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr)
 {
-  attr->stackaddr = stackaddr;
-  attr->stackaddr_set = 1;
+  attr->__stackaddr = stackaddr;
+  attr->__stackaddr_set = 1;
   return 0;
 }
 weak_alias (__pthread_attr_setstackaddr, pthread_attr_setstackaddr)
@@ -175,7 +175,7 @@ int __pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr)
   /* XXX This function has a stupid definition.  The standard specifies
      no error value but what is if no stack address was set?  We simply
      return the value we have in the member.  */
-  *stackaddr = attr->stackaddr;
+  *stackaddr = attr->__stackaddr;
   return 0;
 }
 weak_alias (__pthread_attr_getstackaddr, pthread_attr_getstackaddr)
@@ -186,14 +186,14 @@ int __pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize)
   if (stacksize < PTHREAD_STACK_MIN)
     return EINVAL;
 
-  attr->stacksize = stacksize;
+  attr->__stacksize = stacksize;
   return 0;
 }
 weak_alias (__pthread_attr_setstacksize, pthread_attr_setstacksize)
 
 int __pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize)
 {
-  *stacksize = attr->stacksize;
+  *stacksize = attr->__stacksize;
   return 0;
 }
 weak_alias (__pthread_attr_getstacksize, pthread_attr_getstacksize)
index e9cb10c..3ff5954 100644 (file)
@@ -77,9 +77,9 @@ void _pthread_cleanup_push(struct _pthread_cleanup_buffer * buffer,
                           void (*routine)(void *), void * arg)
 {
   pthread_descr self = thread_self();
-  buffer->routine = routine;
-  buffer->arg = arg;
-  buffer->prev = THREAD_GETMEM(self, p_cleanup);
+  buffer->__routine = routine;
+  buffer->__arg = arg;
+  buffer->__prev = THREAD_GETMEM(self, p_cleanup);
   THREAD_SETMEM(self, p_cleanup, buffer);
 }
 
@@ -87,18 +87,18 @@ void _pthread_cleanup_pop(struct _pthread_cleanup_buffer * buffer,
                          int execute)
 {
   pthread_descr self = thread_self();
-  if (execute) buffer->routine(buffer->arg);
-  THREAD_SETMEM(self, p_cleanup, buffer->prev);
+  if (execute) buffer->__routine(buffer->__arg);
+  THREAD_SETMEM(self, p_cleanup, buffer->__prev);
 }
 
 void _pthread_cleanup_push_defer(struct _pthread_cleanup_buffer * buffer,
                                 void (*routine)(void *), void * arg)
 {
   pthread_descr self = thread_self();
-  buffer->routine = routine;
-  buffer->arg = arg;
-  buffer->canceltype = THREAD_GETMEM(self, p_canceltype);
-  buffer->prev = THREAD_GETMEM(self, p_cleanup);
+  buffer->__routine = routine;
+  buffer->__arg = arg;
+  buffer->__canceltype = THREAD_GETMEM(self, p_canceltype);
+  buffer->__prev = THREAD_GETMEM(self, p_cleanup);
   THREAD_SETMEM(self, p_canceltype, PTHREAD_CANCEL_DEFERRED);
   THREAD_SETMEM(self, p_cleanup, buffer);
 }
@@ -107,9 +107,9 @@ void _pthread_cleanup_pop_restore(struct _pthread_cleanup_buffer * buffer,
                                  int execute)
 {
   pthread_descr self = thread_self();
-  if (execute) buffer->routine(buffer->arg);
-  THREAD_SETMEM(self, p_cleanup, buffer->prev);
-  THREAD_SETMEM(self, p_canceltype, buffer->canceltype);
+  if (execute) buffer->__routine(buffer->__arg);
+  THREAD_SETMEM(self, p_cleanup, buffer->__prev);
+  THREAD_SETMEM(self, p_canceltype, buffer->__canceltype);
   if (THREAD_GETMEM(self, p_canceled) &&
       THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE &&
       THREAD_GETMEM(self, p_canceltype) == PTHREAD_CANCEL_ASYNCHRONOUS)
@@ -120,8 +120,8 @@ void __pthread_perform_cleanup(void)
 {
   pthread_descr self = thread_self();
   struct _pthread_cleanup_buffer * c;
-  for (c = THREAD_GETMEM(self, p_cleanup); c != NULL; c = c->prev)
-    c->routine(c->arg);
+  for (c = THREAD_GETMEM(self, p_cleanup); c != NULL; c = c->__prev)
+    c->__routine(c->__arg);
 }
 
 #ifndef PIC
index 773d714..b880a38 100644 (file)
 int pthread_cond_init(pthread_cond_t *cond,
                       const pthread_condattr_t *cond_attr)
 {
-  __pthread_init_lock(&cond->c_lock);
-  cond->c_waiting = NULL;
+  __pthread_init_lock(&cond->__c_lock);
+  cond->__c_waiting = NULL;
   return 0;
 }
 
 int pthread_cond_destroy(pthread_cond_t *cond)
 {
-  if (cond->c_waiting != NULL) return EBUSY;
+  if (cond->__c_waiting != NULL) return EBUSY;
   return 0;
 }
 
@@ -43,9 +43,9 @@ int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
 {
   volatile pthread_descr self = thread_self();
 
-  __pthread_lock(&cond->c_lock);
-  enqueue(&cond->c_waiting, self);
-  __pthread_unlock(&cond->c_lock);
+  __pthread_lock(&cond->__c_lock);
+  enqueue(&cond->__c_waiting, self);
+  __pthread_unlock(&cond->__c_lock);
   pthread_mutex_unlock(mutex);
   suspend_with_cancellation(self);
   pthread_mutex_lock(mutex);
@@ -53,9 +53,9 @@ int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
   if (THREAD_GETMEM(self, p_canceled)
       && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {
     /* Remove ourselves from the waiting queue if we're still on it */
-    __pthread_lock(&cond->c_lock);
-    remove_from_queue(&cond->c_waiting, self);
-    __pthread_unlock(&cond->c_lock);
+    __pthread_lock(&cond->__c_lock);
+    remove_from_queue(&cond->__c_waiting, self);
+    __pthread_unlock(&cond->__c_lock);
     pthread_exit(PTHREAD_CANCELED);
   }
   return 0;
@@ -72,9 +72,9 @@ pthread_cond_timedwait_relative(pthread_cond_t *cond,
   sigjmp_buf jmpbuf;
 
   /* Wait on the condition */
-  __pthread_lock(&cond->c_lock);
-  enqueue(&cond->c_waiting, self);
-  __pthread_unlock(&cond->c_lock);
+  __pthread_lock(&cond->__c_lock);
+  enqueue(&cond->__c_waiting, self);
+  __pthread_unlock(&cond->__c_lock);
   pthread_mutex_unlock(mutex);
   /* Set up a longjmp handler for the restart and cancel signals */
   if (sigsetjmp(jmpbuf, 1) == 0) {
@@ -107,17 +107,17 @@ pthread_cond_timedwait_relative(pthread_cond_t *cond,
   /* This is a cancellation point */
   if (THREAD_GETMEM(self, p_canceled)
       && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {
-    __pthread_lock(&cond->c_lock);
-    remove_from_queue(&cond->c_waiting, self);
-    __pthread_unlock(&cond->c_lock);
+    __pthread_lock(&cond->__c_lock);
+    remove_from_queue(&cond->__c_waiting, self);
+    __pthread_unlock(&cond->__c_lock);
     pthread_mutex_lock(mutex);
     pthread_exit(PTHREAD_CANCELED);
   }
   /* If not signaled: also remove ourselves and return an error code */
   if (THREAD_GETMEM(self, p_signal) == 0) {
-    __pthread_lock(&cond->c_lock);
-    remove_from_queue(&cond->c_waiting, self);
-    __pthread_unlock(&cond->c_lock);
+    __pthread_lock(&cond->__c_lock);
+    remove_from_queue(&cond->__c_waiting, self);
+    __pthread_unlock(&cond->__c_lock);
     pthread_mutex_lock(mutex);
     return retsleep == 0 ? ETIMEDOUT : EINTR;
   }
@@ -147,9 +147,9 @@ int pthread_cond_signal(pthread_cond_t *cond)
 {
   pthread_descr th;
 
-  __pthread_lock(&cond->c_lock);
-  th = dequeue(&cond->c_waiting);
-  __pthread_unlock(&cond->c_lock);
+  __pthread_lock(&cond->__c_lock);
+  th = dequeue(&cond->__c_waiting);
+  __pthread_unlock(&cond->__c_lock);
   if (th != NULL) restart(th);
   return 0;
 }
@@ -158,11 +158,11 @@ int pthread_cond_broadcast(pthread_cond_t *cond)
 {
   pthread_descr tosignal, th;
 
-  __pthread_lock(&cond->c_lock);
+  __pthread_lock(&cond->__c_lock);
   /* Copy the current state of the waiting queue and empty it */
-  tosignal = cond->c_waiting;
-  cond->c_waiting = NULL;
-  __pthread_unlock(&cond->c_lock);
+  tosignal = cond->__c_waiting;
+  cond->__c_waiting = NULL;
+  __pthread_unlock(&cond->__c_lock);
   /* Now signal each process in the queue */
   while ((th = dequeue(&tosignal)) != NULL) restart(th);
   return 0;
index d145395..b6107da 100644 (file)
@@ -222,12 +222,12 @@ static int pthread_allocate_stack(const pthread_attr_t *attr,
   char * guardaddr;
   size_t stacksize, guardsize;
 
-  if (attr != NULL && attr->stackaddr_set)
+  if (attr != NULL && attr->__stackaddr_set)
     {
       /* The user provided a stack. */
       new_thread =
-        (pthread_descr) ((long)(attr->stackaddr) & -sizeof(void *)) - 1;
-      new_thread_bottom = (char *) attr->stackaddr - attr->stacksize;
+        (pthread_descr) ((long)(attr->__stackaddr) & -sizeof(void *)) - 1;
+      new_thread_bottom = (char *) attr->__stackaddr - attr->__stacksize;
       guardaddr = NULL;
       guardsize = 0;
     }
@@ -249,9 +249,9 @@ static int pthread_allocate_stack(const pthread_attr_t *attr,
          the RLIMIT_STACK soft limit prevents stacks from
          running into one another. */
       if (attr == NULL ||
-          attr->guardsize == 0 ||
-          (attr->guardsize == pagesize &&
-           attr->stacksize == STACK_SIZE - pagesize))
+          attr->__guardsize == 0 ||
+          (attr->__guardsize == pagesize &&
+           attr->__stacksize == STACK_SIZE - pagesize))
         {
           /* We don't need a guard page. */
           guardaddr = NULL;
@@ -260,11 +260,11 @@ static int pthread_allocate_stack(const pthread_attr_t *attr,
       else
         {
           /* Put a bad page at the bottom of the stack */
-          stacksize = roundup(attr->stacksize, pagesize);
+          stacksize = roundup(attr->__stacksize, pagesize);
           if (stacksize >= STACK_SIZE - pagesize)
             stacksize = STACK_SIZE - pagesize;
           guardaddr = (void *)new_thread - stacksize;
-          guardsize = attr->guardsize;
+          guardsize = attr->__guardsize;
           if (mmap ((caddr_t) guardaddr, guardsize, 0, MAP_FIXED, -1, 0)
               == MAP_FAILED)
             {
@@ -298,7 +298,7 @@ static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
      we can  do this.  Normally this should be done by examining the
      return value of the __sched_setscheduler call in pthread_start_thread
      but this is hard to implement.  FIXME  */
-  if (attr != NULL && attr->schedpolicy != SCHED_OTHER && geteuid () != 0)
+  if (attr != NULL && attr->__schedpolicy != SCHED_OTHER && geteuid () != 0)
     return EPERM;
   /* Find a free segment for the thread, and allocate a stack if needed */
   for (sseg = 2; ; sseg++)
@@ -324,7 +324,7 @@ static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
   new_thread->p_signal_jmp = NULL;
   new_thread->p_cancel_jmp = NULL;
   new_thread->p_terminated = 0;
-  new_thread->p_detached = attr == NULL ? 0 : attr->detachstate;
+  new_thread->p_detached = attr == NULL ? 0 : attr->__detachstate;
   new_thread->p_exited = 0;
   new_thread->p_retval = NULL;
   new_thread->p_joining = NULL;
@@ -340,7 +340,7 @@ static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
   new_thread->p_sigwaiting = 0;
   new_thread->p_guardaddr = guardaddr;
   new_thread->p_guardsize = guardsize;
-  new_thread->p_userstack = attr != NULL && attr->stackaddr_set;
+  new_thread->p_userstack = attr != NULL && attr->__stackaddr_set;
   memset (new_thread->p_specific, '\0',
          PTHREAD_KEY_1STLEVEL_SIZE * sizeof (new_thread->p_specific[0]));
   new_thread->p_self = new_thread;
@@ -352,10 +352,10 @@ static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
   /* Determine scheduling parameters for the thread */
   new_thread->p_start_args.schedpolicy = -1;
   if (attr != NULL) {
-    switch(attr->inheritsched) {
+    switch(attr->__inheritsched) {
     case PTHREAD_EXPLICIT_SCHED:
-      new_thread->p_start_args.schedpolicy = attr->schedpolicy;
-      memcpy (&new_thread->p_start_args.schedparam, &attr->schedparam,
+      new_thread->p_start_args.schedpolicy = attr->__schedpolicy;
+      memcpy (&new_thread->p_start_args.schedparam, &attr->__schedparam,
              sizeof (struct sched_param));
       break;
     case PTHREAD_INHERIT_SCHED:
@@ -382,7 +382,7 @@ static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
   /* Check if cloning succeeded */
   if (pid == -1) {
     /* Free the stack if we allocated it */
-    if (attr == NULL || !attr->stackaddr_set)
+    if (attr == NULL || !attr->__stackaddr_set)
       {
        munmap((caddr_t)((char *)(new_thread+1) - INITIAL_STACK_SIZE),
               INITIAL_STACK_SIZE);
index 74b0922..d3ef78c 100644 (file)
 int __pthread_mutex_init(pthread_mutex_t * mutex,
                        const pthread_mutexattr_t * mutex_attr)
 {
-  __pthread_init_lock(&mutex->m_lock);
-  mutex->m_kind =
-    mutex_attr == NULL ? PTHREAD_MUTEX_FAST_NP : mutex_attr->mutexkind;
-  mutex->m_count = 0;
-  mutex->m_owner = NULL;
+  __pthread_init_lock(&mutex->__m_lock);
+  mutex->__m_kind =
+    mutex_attr == NULL ? PTHREAD_MUTEX_FAST_NP : mutex_attr->__mutexkind;
+  mutex->__m_count = 0;
+  mutex->__m_owner = NULL;
   return 0;
 }
 weak_alias (__pthread_mutex_init, pthread_mutex_init)
 
 int __pthread_mutex_destroy(pthread_mutex_t * mutex)
 {
-  if (mutex->m_lock.status != 0) return EBUSY;
+  if (mutex->__m_lock.__status != 0) return EBUSY;
   return 0;
 }
 weak_alias (__pthread_mutex_destroy, pthread_mutex_destroy)
@@ -47,26 +47,26 @@ int __pthread_mutex_trylock(pthread_mutex_t * mutex)
   pthread_descr self;
   int retcode;
 
-  switch(mutex->m_kind) {
+  switch(mutex->__m_kind) {
   case PTHREAD_MUTEX_FAST_NP:
-    retcode = __pthread_trylock(&mutex->m_lock);
+    retcode = __pthread_trylock(&mutex->__m_lock);
     return retcode;
   case PTHREAD_MUTEX_RECURSIVE_NP:
     self = thread_self();
-    if (mutex->m_owner == self) {
-      mutex->m_count++;
+    if (mutex->__m_owner == self) {
+      mutex->__m_count++;
       return 0;
     }
-    retcode = __pthread_trylock(&mutex->m_lock);
+    retcode = __pthread_trylock(&mutex->__m_lock);
     if (retcode == 0) {
-      mutex->m_owner = self;
-      mutex->m_count = 0;
+      mutex->__m_owner = self;
+      mutex->__m_count = 0;
     }
     return retcode;
   case PTHREAD_MUTEX_ERRORCHECK_NP:
-    retcode = __pthread_trylock(&mutex->m_lock);
+    retcode = __pthread_trylock(&mutex->__m_lock);
     if (retcode == 0) {
-      mutex->m_owner = thread_self();
+      mutex->__m_owner = thread_self();
     }
     return retcode;
   default:
@@ -79,25 +79,25 @@ int __pthread_mutex_lock(pthread_mutex_t * mutex)
 {
   pthread_descr self;
 
-  switch(mutex->m_kind) {
+  switch(mutex->__m_kind) {
   case PTHREAD_MUTEX_FAST_NP:
-    __pthread_lock(&mutex->m_lock);
+    __pthread_lock(&mutex->__m_lock);
     return 0;
   case PTHREAD_MUTEX_RECURSIVE_NP:
     self = thread_self();
-    if (mutex->m_owner == self) {
-      mutex->m_count++;
+    if (mutex->__m_owner == self) {
+      mutex->__m_count++;
       return 0;
     }
-    __pthread_lock(&mutex->m_lock);
-    mutex->m_owner = self;
-    mutex->m_count = 0;
+    __pthread_lock(&mutex->__m_lock);
+    mutex->__m_owner = self;
+    mutex->__m_count = 0;
     return 0;
   case PTHREAD_MUTEX_ERRORCHECK_NP:
     self = thread_self();
-    if (mutex->m_owner == self) return EDEADLK;
-    __pthread_lock(&mutex->m_lock);
-    mutex->m_owner = self;
+    if (mutex->__m_owner == self) return EDEADLK;
+    __pthread_lock(&mutex->__m_lock);
+    mutex->__m_owner = self;
     return 0;
   default:
     return EINVAL;
@@ -107,23 +107,23 @@ weak_alias (__pthread_mutex_lock, pthread_mutex_lock)
 
 int __pthread_mutex_unlock(pthread_mutex_t * mutex)
 {
-  switch (mutex->m_kind) {
+  switch (mutex->__m_kind) {
   case PTHREAD_MUTEX_FAST_NP:
-    __pthread_unlock(&mutex->m_lock);
+    __pthread_unlock(&mutex->__m_lock);
     return 0;
   case PTHREAD_MUTEX_RECURSIVE_NP:
-    if (mutex->m_count > 0) {
-      mutex->m_count--;
+    if (mutex->__m_count > 0) {
+      mutex->__m_count--;
       return 0;
     }
-    mutex->m_owner = NULL;
-    __pthread_unlock(&mutex->m_lock);
+    mutex->__m_owner = NULL;
+    __pthread_unlock(&mutex->__m_lock);
     return 0;
   case PTHREAD_MUTEX_ERRORCHECK_NP:
-    if (mutex->m_owner != thread_self() || mutex->m_lock.status == 0)
+    if (mutex->__m_owner != thread_self() || mutex->__m_lock.__status == 0)
       return EPERM;
-    mutex->m_owner = NULL;
-    __pthread_unlock(&mutex->m_lock);
+    mutex->__m_owner = NULL;
+    __pthread_unlock(&mutex->__m_lock);
     return 0;
   default:
     return EINVAL;
@@ -133,7 +133,7 @@ weak_alias (__pthread_mutex_unlock, pthread_mutex_unlock)
 
 int __pthread_mutexattr_init(pthread_mutexattr_t *attr)
 {
-  attr->mutexkind = PTHREAD_MUTEX_FAST_NP;
+  attr->__mutexkind = PTHREAD_MUTEX_FAST_NP;
   return 0;
 }
 weak_alias (__pthread_mutexattr_init, pthread_mutexattr_init)
@@ -150,7 +150,7 @@ int __pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind)
       && kind != PTHREAD_MUTEX_RECURSIVE_NP
       && kind != PTHREAD_MUTEX_ERRORCHECK_NP)
     return EINVAL;
-  attr->mutexkind = kind;
+  attr->__mutexkind = kind;
   return 0;
 }
 weak_alias (__pthread_mutexattr_settype, pthread_mutexattr_settype)
@@ -159,7 +159,7 @@ weak_alias (__pthread_mutexattr_setkind_np, pthread_mutexattr_setkind_np)
 
 int __pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *kind)
 {
-  *kind = attr->mutexkind;
+  *kind = attr->__mutexkind;
   return 0;
 }
 weak_alias (__pthread_mutexattr_gettype, pthread_mutexattr_gettype)
index c7cfdac..d0c66d0 100644 (file)
@@ -340,11 +340,12 @@ int __pthread_create_2_0(pthread_t *thread, const pthread_attr_t *attr,
     {
       size_t ps = __getpagesize ();
 
-      memcpy (&new_attr, attr, (size_t) &(((pthread_attr_t*)NULL)->guardsize));
-      new_attr.guardsize = ps;
-      new_attr.stackaddr_set = 0;
-      new_attr.stackaddr = NULL;
-      new_attr.stacksize = STACK_SIZE - ps;
+      memcpy (&new_attr, attr,
+             (size_t) &(((pthread_attr_t*)NULL)->__guardsize));
+      new_attr.__guardsize = ps;
+      new_attr.__stackaddr_set = 0;
+      new_attr.__stackaddr = NULL;
+      new_attr.__stacksize = STACK_SIZE - ps;
       attr = &new_attr;
     }
   return __pthread_create_2_1 (thread, attr, start_routine, arg);
index 7e4314e..1c12508 100644 (file)
@@ -34,8 +34,8 @@ static void pthread_cleanup_upto(__jmp_buf target)
 
   for (c = THREAD_GETMEM(self, p_cleanup);
        c != NULL && _JMPBUF_UNWINDS(target, c);
-       c = c->prev)
-    c->routine(c->arg);
+       c = c->__prev)
+    c->__routine(c->__arg);
   THREAD_SETMEM(self, p_cleanup, c);
   if (THREAD_GETMEM(self, p_in_sighandler)
       && _JMPBUF_UNWINDS(target, THREAD_GETMEM(self, p_in_sighandler)))
index 99209f7..bff4e38 100644 (file)
@@ -30,21 +30,21 @@ int
 pthread_rwlock_init (pthread_rwlock_t *rwlock,
                     const pthread_rwlockattr_t *attr)
 {
-  __pthread_init_lock(&rwlock->rw_lock);
-  rwlock->rw_readers = 0;
-  rwlock->rw_writer = NULL;
-  rwlock->rw_read_waiting = NULL;
-  rwlock->rw_write_waiting = NULL;
+  __pthread_init_lock(&rwlock->__rw_lock);
+  rwlock->__rw_readers = 0;
+  rwlock->__rw_writer = NULL;
+  rwlock->__rw_read_waiting = NULL;
+  rwlock->__rw_write_waiting = NULL;
 
   if (attr == NULL)
     {
-      rwlock->rw_kind = PTHREAD_RWLOCK_DEFAULT_NP;
-      rwlock->rw_pshared = PTHREAD_PROCESS_PRIVATE;
+      rwlock->__rw_kind = PTHREAD_RWLOCK_DEFAULT_NP;
+      rwlock->__rw_pshared = PTHREAD_PROCESS_PRIVATE;
     }
   else
     {
-      rwlock->rw_kind = attr->lockkind;
-      rwlock->rw_pshared = attr->pshared;
+      rwlock->__rw_kind = attr->__lockkind;
+      rwlock->__rw_pshared = attr->__pshared;
     }
 
   return 0;
@@ -57,10 +57,10 @@ pthread_rwlock_destroy (pthread_rwlock_t *rwlock)
   int readers;
   _pthread_descr writer;
 
-  __pthread_lock (&rwlock->rw_lock);
-  readers = rwlock->rw_readers;
-  writer = rwlock->rw_writer;
-  __pthread_unlock (&rwlock->rw_lock);
+  __pthread_lock (&rwlock->__rw_lock);
+  readers = rwlock->__rw_readers;
+  writer = rwlock->__rw_writer;
+  __pthread_unlock (&rwlock->__rw_lock);
 
   if (readers > 0 || writer != NULL)
     return EBUSY;
@@ -76,22 +76,22 @@ pthread_rwlock_rdlock (pthread_rwlock_t *rwlock)
 
   while (1)
     {
-      __pthread_lock (&rwlock->rw_lock);
-      if (rwlock->rw_writer == NULL
-         || (rwlock->rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
-             && rwlock->rw_readers != 0))
+      __pthread_lock (&rwlock->__rw_lock);
+      if (rwlock->__rw_writer == NULL
+         || (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
+             && rwlock->__rw_readers != 0))
        /* We can add a reader lock.  */
        break;
 
       /* Suspend ourselves, then try again */
       self = thread_self ();
-      enqueue (&rwlock->rw_read_waiting, self);
-      __pthread_unlock (&rwlock->rw_lock);
+      enqueue (&rwlock->__rw_read_waiting, self);
+      __pthread_unlock (&rwlock->__rw_lock);
       suspend (self); /* This is not a cancellation point */
     }
 
-  ++rwlock->rw_readers;
-  __pthread_unlock (&rwlock->rw_lock);
+  ++rwlock->__rw_readers;
+  __pthread_unlock (&rwlock->__rw_lock);
 
   return 0;
 }
@@ -102,15 +102,15 @@ pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock)
 {
   int result = EBUSY;
 
-  __pthread_lock (&rwlock->rw_lock);
-  if (rwlock->rw_writer == NULL
-      || (rwlock->rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
-         && rwlock->rw_readers != 0))
+  __pthread_lock (&rwlock->__rw_lock);
+  if (rwlock->__rw_writer == NULL
+      || (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
+         && rwlock->__rw_readers != 0))
     {
-      ++rwlock->rw_readers;
+      ++rwlock->__rw_readers;
       result = 0;
     }
-  __pthread_unlock (&rwlock->rw_lock);
+  __pthread_unlock (&rwlock->__rw_lock);
 
   return result;
 }
@@ -123,17 +123,17 @@ pthread_rwlock_wrlock (pthread_rwlock_t *rwlock)
 
   while(1)
     {
-      __pthread_lock (&rwlock->rw_lock);
-      if (rwlock->rw_readers == 0 && rwlock->rw_writer == NULL)
+      __pthread_lock (&rwlock->__rw_lock);
+      if (rwlock->__rw_readers == 0 && rwlock->__rw_writer == NULL)
        {
-         rwlock->rw_writer = self;
-         __pthread_unlock (&rwlock->rw_lock);
+         rwlock->__rw_writer = self;
+         __pthread_unlock (&rwlock->__rw_lock);
          return 0;
        }
 
       /* Suspend ourselves, then try again */
-      enqueue (&rwlock->rw_write_waiting, self);
-      __pthread_unlock (&rwlock->rw_lock);
+      enqueue (&rwlock->__rw_write_waiting, self);
+      __pthread_unlock (&rwlock->__rw_lock);
       suspend (self); /* This is not a cancellation point */
     }
 }
@@ -144,13 +144,13 @@ pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock)
 {
   int result = EBUSY;
 
-  __pthread_lock (&rwlock->rw_lock);
-  if (rwlock->rw_readers == 0 && rwlock->rw_writer == NULL)
+  __pthread_lock (&rwlock->__rw_lock);
+  if (rwlock->__rw_readers == 0 && rwlock->__rw_writer == NULL)
     {
-      rwlock->rw_writer = thread_self ();
+      rwlock->__rw_writer = thread_self ();
       result = 0;
     }
-  __pthread_unlock (&rwlock->rw_lock);
+  __pthread_unlock (&rwlock->__rw_lock);
 
   return result;
 }
@@ -162,51 +162,51 @@ pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
   pthread_descr torestart;
   pthread_descr th;
 
-  __pthread_lock (&rwlock->rw_lock);
-  if (rwlock->rw_writer != NULL)
+  __pthread_lock (&rwlock->__rw_lock);
+  if (rwlock->__rw_writer != NULL)
     {
       /* Unlocking a write lock.  */
-      if (rwlock->rw_writer != thread_self ())
+      if (rwlock->__rw_writer != thread_self ())
        {
-         __pthread_unlock (&rwlock->rw_lock);
+         __pthread_unlock (&rwlock->__rw_lock);
          return EPERM;
        }
-      rwlock->rw_writer = NULL;
+      rwlock->__rw_writer = NULL;
 
-      if (rwlock->rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
-         || (th = dequeue (&rwlock->rw_write_waiting)) == NULL)
+      if (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
+         || (th = dequeue (&rwlock->__rw_write_waiting)) == NULL)
        {
          /* Restart all waiting readers.  */
-         torestart = rwlock->rw_read_waiting;
-         rwlock->rw_read_waiting = NULL;
-         __pthread_unlock (&rwlock->rw_lock);
+         torestart = rwlock->__rw_read_waiting;
+         rwlock->__rw_read_waiting = NULL;
+         __pthread_unlock (&rwlock->__rw_lock);
          while ((th = dequeue (&torestart)) != NULL)
            restart (th);
        }
       else
        {
          /* Restart one waiting writer.  */
-         __pthread_unlock (&rwlock->rw_lock);
+         __pthread_unlock (&rwlock->__rw_lock);
          restart (th);
        }
     }
   else
     {
       /* Unlocking a read lock.  */
-      if (rwlock->rw_readers == 0)
+      if (rwlock->__rw_readers == 0)
        {
-         __pthread_unlock (&rwlock->rw_lock);
+         __pthread_unlock (&rwlock->__rw_lock);
          return EPERM;
        }
 
-      --rwlock->rw_readers;
-      if (rwlock->rw_readers == 0)
+      --rwlock->__rw_readers;
+      if (rwlock->__rw_readers == 0)
        /* Restart one waiting writer, if any.  */
-       th = dequeue (&rwlock->rw_write_waiting);
+       th = dequeue (&rwlock->__rw_write_waiting);
       else
        th = NULL;
 
-      __pthread_unlock (&rwlock->rw_lock);
+      __pthread_unlock (&rwlock->__rw_lock);
       if (th != NULL)
        restart (th);
     }
@@ -219,8 +219,8 @@ pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
 int
 pthread_rwlockattr_init (pthread_rwlockattr_t *attr)
 {
-  attr->lockkind = 0;
-  attr->pshared = 0;
+  attr->__lockkind = 0;
+  attr->__pshared = 0;
 
   return 0;
 }
@@ -236,7 +236,7 @@ pthread_rwlockattr_destroy (pthread_rwlockattr_t *attr)
 int
 pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *attr, int *pshared)
 {
-  *pshared = attr->pshared;
+  *pshared = attr->__pshared;
   return 0;
 }
 
@@ -247,7 +247,7 @@ pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared)
   if (pshared != PTHREAD_PROCESS_PRIVATE && pshared != PTHREAD_PROCESS_SHARED)
     return EINVAL;
 
-  attr->pshared = pshared;
+  attr->__pshared = pshared;
 
   return 0;
 }
@@ -256,7 +256,7 @@ pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared)
 int
 pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *attr, int *pref)
 {
-  *pref = attr->lockkind;
+  *pref = attr->__lockkind;
   return 0;
 }
 
@@ -269,7 +269,7 @@ pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *attr, int pref)
       && pref != PTHREAD_RWLOCK_DEFAULT_NP)
     return EINVAL;
 
-  attr->lockkind = pref;
+  attr->__lockkind = pref;
 
   return 0;
 }
index 15faec0..172cb7a 100644 (file)
@@ -42,7 +42,7 @@ void __pthread_lock(struct _pthread_fastlock * lock)
   pthread_descr self = NULL;
 
   do {
-    oldstatus = lock->status;
+    oldstatus = lock->__status;
     if (oldstatus == 0) {
       newstatus = 1;
     } else {
@@ -51,8 +51,8 @@ void __pthread_lock(struct _pthread_fastlock * lock)
     }
     if (self != NULL)
       THREAD_SETMEM(self, p_nextwaiting, (pthread_descr) oldstatus);
-  } while(! compare_and_swap(&lock->status, oldstatus, newstatus,
-                             &lock->spinlock));
+  } while(! compare_and_swap(&lock->__status, oldstatus, newstatus,
+                             &lock->__spinlock));
   if (oldstatus != 0) suspend(self);
 }
 
@@ -61,9 +61,9 @@ int __pthread_trylock(struct _pthread_fastlock * lock)
   long oldstatus;
 
   do {
-    oldstatus = lock->status;
+    oldstatus = lock->__status;
     if (oldstatus != 0) return EBUSY;
-  } while(! compare_and_swap(&lock->status, 0, 1, &lock->spinlock));
+  } while(! compare_and_swap(&lock->__status, 0, 1, &lock->__spinlock));
   return 0;
 }
 
@@ -74,14 +74,15 @@ void __pthread_unlock(struct _pthread_fastlock * lock)
   int maxprio;
 
 again:
-  oldstatus = lock->status;
+  oldstatus = lock->__status;
   if (oldstatus == 1) {
     /* No threads are waiting for this lock */
-    if (! compare_and_swap(&lock->status, 1, 0, &lock->spinlock)) goto again;
+    if (! compare_and_swap(&lock->__status, 1, 0, &lock->__spinlock))
+      goto again;
     return;
   }
   /* Find thread in waiting queue with maximal priority */
-  ptr = (pthread_descr *) &lock->status;
+  ptr = (pthread_descr *) &lock->__status;
   thr = (pthread_descr) oldstatus;
   maxprio = 0;
   maxptr = ptr;
@@ -94,13 +95,13 @@ again:
     thr = *ptr;
   }
   /* Remove max prio thread from waiting list. */
-  if (maxptr == (pthread_descr *) &lock->status) {
+  if (maxptr == (pthread_descr *) &lock->__status) {
     /* If max prio thread is at head, remove it with compare-and-swap
        to guard against concurrent lock operation */
     thr = (pthread_descr) oldstatus;
-    if (! compare_and_swap(&lock->status,
+    if (! compare_and_swap(&lock->__status,
                            oldstatus, (long)(thr->p_nextwaiting),
-                           &lock->spinlock))
+                           &lock->__spinlock))
       goto again;
   } else {
     /* No risk of concurrent access, remove max prio thread normally */
index d21a967..a6f682c 100644 (file)
@@ -20,8 +20,8 @@ extern void __pthread_unlock(struct _pthread_fastlock * lock);
 
 static inline void __pthread_init_lock(struct _pthread_fastlock * lock)
 {
-  lock->status = 0;
-  lock->spinlock = 0;
+  lock->__status = 0;
+  lock->__spinlock = 0;
 }
 
 #define LOCK_INITIALIZER {0, 0}