--- a/libpthread/linuxthreads.old/attr.c	2006-01-24 12:41:01.000000000 -0500
+++ b/libpthread/linuxthreads.old/attr.c	2008-02-10 11:35:32.000000000 -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.000000000 -0500
+++ b/libpthread/linuxthreads.old/sysdeps/pthread/pthread.h	2008-02-10 11:42:35.000000000 -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 pthread_exit.  ROUTINE will also