--- 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