Hi,
Attached 72_all_uClibc-0.9.29-linuxthreads.patch is from gentoo as in
http://bugs.busybox.net/view.php?id=5134
Can somebody who is involved with threads take a look?
--- a/libpthread/linuxthreads.old/attr.c 2006-01-24 12:41:01.0 -0500
+++ b/libpthread/linuxthreads.old/attr.c 2008-02-10 11:35:32.0 -0500
@@ -25,6 +25,14 @@
#include pthread.h
#include internals.h
+#include sys/resource.h
+#include inttypes.h
+#include stdio.h
+#include stdio_ext.h
+#include stdlib.h
+#include sys/resource.h
+
+
/* NOTE: With uClibc I don't think we need this versioning stuff.
* Therefore, define the function pthread_attr_init() here using
* a strong symbol. */
@@ -209,4 +217,94 @@ int __pthread_attr_getstacksize(const pt
*stacksize = attr-__stacksize;
return 0;
}
+
+
+extern int *__libc_stack_end;
+
weak_alias (__pthread_attr_getstacksize, pthread_attr_getstacksize)
+void* pthread_getattr_np(pthread_t thread, pthread_attr_t *attr)
+{
+static void *stackBase = 0;
+static size_t stackSize = 0;
+int ret = 0;
+/* 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, %x-%x, 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);
+}
+#ifndef _STACK_GROWS_UP
+stackBase = (char *) attr-__stackaddr - attr-__stacksize;
+#else
+stackBase = attr-__stackaddr;
+#endif
+stackSize = attr-__stacksize;
+return (void*)(stackBase + stackSize);
+}
+
+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)
--- a/libpthread/linuxthreads.old/sysdeps/pthread/pthread.h 2006-12-07 22:19:36.0 -0500
+++ b/libpthread/linuxthreads.old/sysdeps/pthread/pthread.h 2008-02-10 11:42:35.0 -0500
@@ -288,15 +288,11 @@ extern int pthread_attr_getstacksize (__
__attr, size_t *__restrict __stacksize)
__THROW;
-#if 0
-/* Not yet implemented in uClibc! */
-
#ifdef __USE_GNU
/* Initialize thread attribute *ATTR with attributes corresponding to the
already running thread TH. It shall be called on unitialized ATTR
and destroyed with pthread_attr_destroy when no longer needed. */
-extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) __THROW;
-#endif
+extern void* pthread_getattr_np(pthread_t thread, pthread_attr_t *attr);
#endif
/* Functions for scheduling control. */
@@ -599,6 +595,11 @@ extern int pthread_cancel (pthread_t __c
cancelled. */
extern void pthread_testcancel (void);
+/* Return the previously set address for the stack. */
+extern int pthread_attr_getstack (__const pthread_attr_t *__restrict __attr,
+ void **__restrict __stackaddr,
+ size_t *__restrict __stacksize) __THROW;
+
/* Install a cleanup handler: ROUTINE will be called with arguments ARG
when the thread is cancelled or calls
