Revert "resolve merge"

This reverts commit 6b6ede3d15f04fe825cfa9f697507457e3640344.

1 files changed, 303 insertions, 74 deletions

diff --git a/libpthread/linuxthreads/attr.c b/libpthread/linuxthreads/attr.c
index 8465c234c..a621c2dcc 100644
--- a/libpthread/linuxthreads/attr.c
+++ b/libpthread/linuxthreads/attr.c
@@ -12,82 +12,49 @@
 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        */
 /* GNU Library General Public License for more details.                 */
 
-/* changed for uClibc */
-#define __sched_get_priority_min sched_get_priority_min
-#define __sched_get_priority_max sched_get_priority_max
-
 /* Handling of thread attributes */
 
 #include <errno.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdio_ext.h>
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/param.h>
+#include <sys/resource.h>
 #include "pthread.h"
 #include "internals.h"
 
-libpthread_hidden_proto(pthread_attr_destroy)
-libpthread_hidden_proto(pthread_attr_init)
-libpthread_hidden_proto(pthread_attr_getdetachstate)
-libpthread_hidden_proto(pthread_attr_setdetachstate)
-libpthread_hidden_proto(pthread_attr_getinheritsched)
-libpthread_hidden_proto(pthread_attr_setinheritsched)
-libpthread_hidden_proto(pthread_attr_setschedparam)
-libpthread_hidden_proto(pthread_attr_getschedparam)
-libpthread_hidden_proto(pthread_attr_getschedpolicy)
-libpthread_hidden_proto(pthread_attr_setschedpolicy)
-libpthread_hidden_proto(pthread_attr_getscope)
-libpthread_hidden_proto(pthread_attr_setscope)
-
-/* NOTE: With uClibc I don't think we need this versioning stuff.
- * Therefore, define the function pthread_attr_init() here using
- * a strong symbol. */
 
-/*int __pthread_attr_init_2_1(pthread_attr_t *attr)*/
-int pthread_attr_init(pthread_attr_t *attr)
+int __pthread_attr_init(pthread_attr_t *attr)
 {
-  size_t ps = getpagesize ();
+  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;
+#ifdef NEED_SEPARATE_REGISTER_STACK
+  attr->__guardsize = ps + ps;
+#else
   attr->__guardsize = ps;
+#endif
   attr->__stackaddr = NULL;
   attr->__stackaddr_set = 0;
   attr->__stacksize = STACK_SIZE - ps;
   return 0;
 }
-libpthread_hidden_def(pthread_attr_init)
-
-/* uClibc: leave out this for now. */
-#if defined DO_PTHREAD_VERSIONING_WITH_UCLIBC
-#if defined __PIC__ && defined DO_VERSIONING
-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;
-  return 0;
-}
-symbol_version (__pthread_attr_init_2_0, pthread_attr_init, GLIBC_2.0);
-#else
-strong_alias (__pthread_attr_init_2_1, pthread_attr_init)
-#endif
-#endif /* DO_PTHREAD_VERSIONING_WITH_UCLIBC */
+strong_alias (__pthread_attr_init, pthread_attr_init)
 
-int pthread_attr_destroy(pthread_attr_t *attr attribute_unused)
+int __pthread_attr_destroy(pthread_attr_t *attr)
 {
   return 0;
 }
-libpthread_hidden_def(pthread_attr_destroy)
-
+strong_alias (__pthread_attr_destroy, pthread_attr_destroy)
 
-int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
+int __pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
 {
   if (detachstate < PTHREAD_CREATE_JOINABLE ||
       detachstate > PTHREAD_CREATE_DETACHED)
@@ -95,17 +62,17 @@ int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
   attr->__detachstate = detachstate;
   return 0;
 }
-libpthread_hidden_def(pthread_attr_setdetachstate)
+strong_alias (__pthread_attr_setdetachstate, pthread_attr_setdetachstate)
 
-int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate)
+int __pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate)
 {
   *detachstate = attr->__detachstate;
   return 0;
 }
-libpthread_hidden_def(pthread_attr_getdetachstate)
+strong_alias (__pthread_attr_getdetachstate, pthread_attr_getdetachstate)
 
-int pthread_attr_setschedparam(pthread_attr_t *attr,
-                               const struct sched_param *param)
+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);
@@ -115,49 +82,49 @@ int pthread_attr_setschedparam(pthread_attr_t *attr,
   memcpy (&attr->__schedparam, param, sizeof (struct sched_param));
   return 0;
 }
-libpthread_hidden_def(pthread_attr_setschedparam)
+strong_alias (__pthread_attr_setschedparam, pthread_attr_setschedparam)
 
-int pthread_attr_getschedparam(const pthread_attr_t *attr,
-                               struct sched_param *param)
+int __pthread_attr_getschedparam(const pthread_attr_t *attr,
+                                 struct sched_param *param)
 {
   memcpy (param, &attr->__schedparam, sizeof (struct sched_param));
   return 0;
 }
-libpthread_hidden_def(pthread_attr_getschedparam)
+strong_alias (__pthread_attr_getschedparam, pthread_attr_getschedparam)
 
-int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy)
+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;
   return 0;
 }
-libpthread_hidden_def(pthread_attr_setschedpolicy)
+strong_alias (__pthread_attr_setschedpolicy, pthread_attr_setschedpolicy)
 
-int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy)
+int __pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy)
 {
   *policy = attr->__schedpolicy;
   return 0;
 }
-libpthread_hidden_def(pthread_attr_getschedpolicy)
+strong_alias (__pthread_attr_getschedpolicy, pthread_attr_getschedpolicy)
 
-int pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit)
+int __pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit)
 {
   if (inherit != PTHREAD_INHERIT_SCHED && inherit != PTHREAD_EXPLICIT_SCHED)
     return EINVAL;
   attr->__inheritsched = inherit;
   return 0;
 }
-libpthread_hidden_def(pthread_attr_setinheritsched)
+strong_alias (__pthread_attr_setinheritsched, pthread_attr_setinheritsched)
 
-int pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inherit)
+int __pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inherit)
 {
   *inherit = attr->__inheritsched;
   return 0;
 }
-libpthread_hidden_def(pthread_attr_getinheritsched)
+strong_alias (__pthread_attr_getinheritsched, pthread_attr_getinheritsched)
 
-int pthread_attr_setscope(pthread_attr_t *attr, int scope)
+int __pthread_attr_setscope(pthread_attr_t *attr, int scope)
 {
   switch (scope) {
   case PTHREAD_SCOPE_SYSTEM:
@@ -169,22 +136,17 @@ int pthread_attr_setscope(pthread_attr_t *attr, int scope)
     return EINVAL;
   }
 }
-libpthread_hidden_def(pthread_attr_setscope)
+strong_alias (__pthread_attr_setscope, pthread_attr_setscope)
 
-int pthread_attr_getscope(const pthread_attr_t *attr, int *scope)
+int __pthread_attr_getscope(const pthread_attr_t *attr, int *scope)
 {
   *scope = attr->__scope;
   return 0;
 }
-libpthread_hidden_def(pthread_attr_getscope)
+strong_alias (__pthread_attr_getscope, pthread_attr_getscope)
 
 int __pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize)
 {
-  size_t ps = getpagesize ();
-
-  /* First round up the guard size.  */
-  guardsize = roundup (guardsize, ps);
-
   /* The guard size must not be larger than the stack itself */
   if (guardsize >= attr->__stacksize) return EINVAL;
 
@@ -210,6 +172,9 @@ int __pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr)
 }
 weak_alias (__pthread_attr_setstackaddr, pthread_attr_setstackaddr)
 
+link_warning (pthread_attr_setstackaddr,
+	      "the use of `pthread_attr_setstackaddr' is deprecated, use `pthread_attr_setstack'")
+
 int __pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr)
 {
   /* XXX This function has a stupid definition.  The standard specifies
@@ -219,10 +184,29 @@ int __pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr)
   return 0;
 }
 weak_alias (__pthread_attr_getstackaddr, pthread_attr_getstackaddr)
+
+link_warning (pthread_attr_getstackaddr,
+	      "the use of `pthread_attr_getstackaddr' is deprecated, use `pthread_attr_getstack'")
 #endif
 
+
 int __pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize)
 {
+#ifdef FLOATING_STACKS
+  /* We have to check against the maximum allowed stack size.  This is no
+     problem if the manager is already started and we determined it.  If
+     this hasn't happened, we have to find the limit outself.  */
+  if (__pthread_max_stacksize == 0)
+    __pthread_init_max_stacksize ();
+
+  if (stacksize > __pthread_max_stacksize)
+    return EINVAL;
+#else
+  /* We have a fixed size limit.  */
+  if (stacksize > STACK_SIZE)
+    return EINVAL;
+#endif
+
   /* We don't accept value smaller than PTHREAD_STACK_MIN.  */
   if (stacksize < PTHREAD_STACK_MIN)
     return EINVAL;
@@ -230,7 +214,44 @@ int __pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize)
   attr->__stacksize = stacksize;
   return 0;
 }
+
+#if PTHREAD_STACK_MIN == 16384 || defined __UCLIBC__
 weak_alias (__pthread_attr_setstacksize, pthread_attr_setstacksize)
+#else
+versioned_symbol (libpthread, __pthread_attr_setstacksize,
+                  pthread_attr_setstacksize, GLIBC_2_3_3);
+
+# if SHLIB_COMPAT(libpthread, GLIBC_2_1, GLIBC_2_3_3)
+
+int __old_pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize)
+{
+#  ifdef FLOATING_STACKS
+  /* We have to check against the maximum allowed stack size.  This is no
+     problem if the manager is already started and we determined it.  If
+     this hasn't happened, we have to find the limit outself.  */
+  if (__pthread_max_stacksize == 0)
+    __pthread_init_max_stacksize ();
+
+  if (stacksize > __pthread_max_stacksize)
+    return EINVAL;
+#  else
+  /* We have a fixed size limit.  */
+  if (stacksize > STACK_SIZE)
+    return EINVAL;
+#  endif
+
+  /* We don't accept value smaller than old PTHREAD_STACK_MIN.  */
+  if (stacksize < 16384)
+    return EINVAL;
+
+  attr->__stacksize = stacksize;
+  return 0;
+}
+compat_symbol (libpthread, __old_pthread_attr_setstacksize,
+	       pthread_attr_setstacksize, GLIBC_2_1);
+# endif
+#endif
+
 
 int __pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize)
 {
@@ -238,3 +259,211 @@ int __pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize)
   return 0;
 }
 weak_alias (__pthread_attr_getstacksize, pthread_attr_getstacksize)
+
+int __pthread_attr_setstack (pthread_attr_t *attr, void *stackaddr,
+			     size_t stacksize)
+{
+  int err;
+
+  if ((((uintptr_t) stackaddr)
+       & (__alignof__ (struct _pthread_descr_struct) - 1)) != 0)
+    err = EINVAL;
+  else
+    err = __pthread_attr_setstacksize (attr, stacksize);
+  if (err == 0)
+    {
+#ifndef _STACK_GROWS_UP
+      attr->__stackaddr = (char *) stackaddr + stacksize;
+#else
+      attr->__stackaddr = stackaddr;
+#endif
+      attr->__stackaddr_set = 1;
+    }
+
+  return err;
+}
+
+#if PTHREAD_STACK_MIN == 16384 || defined __UCLIBC__
+weak_alias (__pthread_attr_setstack, pthread_attr_setstack)
+#else
+versioned_symbol (libpthread, __pthread_attr_setstack, pthread_attr_setstack,
+                  GLIBC_2_3_3);
+# if SHLIB_COMPAT(libpthread, GLIBC_2_2, GLIBC_2_3_3)
+int __old_pthread_attr_setstack (pthread_attr_t *attr, void *stackaddr,
+				 size_t stacksize)
+{
+  int err;
+
+  if ((((uintptr_t) stackaddr)
+       & (__alignof__ (struct _pthread_descr_struct) - 1)) != 0)
+    err = EINVAL;
+  else
+    err = __old_pthread_attr_setstacksize (attr, stacksize);
+  if (err == 0)
+    {
+#  ifndef _STACK_GROWS_UP
+      attr->__stackaddr = (char *) stackaddr + stacksize;
+#  else
+      attr->__stackaddr = stackaddr;
+#  endif
+      attr->__stackaddr_set = 1;
+    }
+
+  return err;
+}
+
+compat_symbol (libpthread, __old_pthread_attr_setstack, pthread_attr_setstack,
+               GLIBC_2_2);
+
+# endif
+#endif
+
+int __pthread_attr_getstack (const pthread_attr_t *attr, void **stackaddr,
+			     size_t *stacksize)
+{
+  /* 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.  */
+#ifndef _STACK_GROWS_UP
+  *stackaddr = (char *) attr->__stackaddr - attr->__stacksize;
+#else
+  *stackaddr = attr->__stackaddr;
+#endif
+  *stacksize = attr->__stacksize;
+  return 0;
+}
+weak_alias (__pthread_attr_getstack, pthread_attr_getstack)
+
+int pthread_getattr_np (pthread_t thread, pthread_attr_t *attr)
+{
+  pthread_handle handle = thread_handle (thread);
+  pthread_descr descr;
+  int ret = 0;
+
+  if (handle == NULL)
+    return ENOENT;
+
+  descr = handle->h_descr;
+
+  attr->__detachstate = (descr->p_detached
+			 ? PTHREAD_CREATE_DETACHED
+			 : PTHREAD_CREATE_JOINABLE);
+
+  attr->__schedpolicy = __sched_getscheduler (descr->p_pid);
+  if (attr->__schedpolicy == -1)
+    return errno;
+
+  if (__sched_getparam (descr->p_pid,
+			(struct sched_param *) &attr->__schedparam) != 0)
+    return errno;
+
+  attr->__inheritsched = descr->p_inheritsched;
+  attr->__scope = PTHREAD_SCOPE_SYSTEM;
+
+#ifdef _STACK_GROWS_DOWN
+# ifdef __UCLIBC_HAS_TLS__
+  attr->__stacksize = descr->p_stackaddr - (char *)descr->p_guardaddr
+		      - descr->p_guardsize;
+# else
+  attr->__stacksize = (char *)(descr + 1) - (char *)descr->p_guardaddr
+		      - descr->p_guardsize;
+# endif
+#else
+# ifdef __UCLIBC_HAS_TLS__
+  attr->__stacksize = (char *)descr->p_guardaddr - descr->p_stackaddr;
+# else
+  attr->__stacksize = (char *)descr->p_guardaddr - (char *)descr;
+# endif
+#endif
+  attr->__guardsize = descr->p_guardsize;
+  attr->__stackaddr_set = descr->p_userstack;
+#ifdef NEED_SEPARATE_REGISTER_STACK
+  if (descr->p_userstack == 0)
+    attr->__stacksize *= 2;
+  /* XXX This is awkward.  The guard pages are in the middle of the
+     two stacks.  We must count the guard size in the stack size since
+     otherwise the range of the stack area cannot be computed.  */
+  attr->__stacksize += attr->__guardsize;
+#endif
+#ifdef __UCLIBC_HAS_TLS__
+  attr->__stackaddr = descr->p_stackaddr;
+#else
+# ifndef _STACK_GROWS_UP
+  attr->__stackaddr = (char *)(descr + 1);
+# else
+  attr->__stackaddr = (char *)descr;
+# endif
+#endif
+
+#ifdef __UCLIBC_HAS_TLS__
+  if (attr->__stackaddr == NULL)
+#else
+  if (descr == &__pthread_initial_thread)
+#endif
+    {
+      /* Stack size limit.  */
+      struct rlimit rl;
+
+      /* The safest way to get the top of the stack is to read
+	 /proc/self/maps and locate the line into which
+	 __libc_stack_end falls.  */
+      FILE *fp = fopen ("/proc/self/maps", "rc");
+      if (fp == NULL)
+	ret = errno;
+      /* We need the limit of the stack in any case.  */
+      else if (getrlimit (RLIMIT_STACK, &rl) != 0)
+	ret = errno;
+      else
+	{
+	  /* We need no locking.  */
+	  __fsetlocking (fp, FSETLOCKING_BYCALLER);
+
+	  /* Until we found an entry (which should always be the case)
+	     mark the result as a failure.  */
+	  ret = ENOENT;
+
+	  char *line = NULL;
+	  size_t linelen = 0;
+	  uintptr_t last_to = 0;
+
+	  while (! feof_unlocked (fp))
+	    {
+	      if (getdelim (&line, &linelen, '\n', fp) <= 0)
+		break;
+
+	      uintptr_t from;
+	      uintptr_t to;
+	      if (sscanf (line, "%" SCNxPTR "-%" SCNxPTR, &from, &to) != 2)
+		continue;
+	      if (from <= (uintptr_t) __libc_stack_end
+		  && (uintptr_t) __libc_stack_end < to)
+		{
+		  /* Found the entry.  Now we have the info we need.  */
+		  attr->__stacksize = rl.rlim_cur;
+#ifdef _STACK_GROWS_UP
+		  /* Don't check to enforce a limit on the __stacksize */
+		  attr->__stackaddr = (void *) from;
+#else
+		  attr->__stackaddr = (void *) to;
+
+		  /* The limit might be too high.  */
+		  if ((size_t) attr->__stacksize
+		      > (size_t) attr->__stackaddr - last_to)
+		    attr->__stacksize = (size_t) attr->__stackaddr - last_to;
+#endif
+
+		  /* We succeed and no need to look further.  */
+		  ret = 0;
+		  break;
+		}
+	      last_to = to;
+	    }
+
+	  fclose (fp);
+	  free (line);
+	}
+    }
+
+  return 0;
+
+}