summaryrefslogtreecommitdiffstats
path: root/toolchain/uClibc/uClibc-0.9.29-linuxthreads.patch
diff options
context:
space:
mode:
Diffstat (limited to 'toolchain/uClibc/uClibc-0.9.29-linuxthreads.patch')
-rw-r--r--toolchain/uClibc/uClibc-0.9.29-linuxthreads.patch145
1 files changed, 145 insertions, 0 deletions
diff --git a/toolchain/uClibc/uClibc-0.9.29-linuxthreads.patch b/toolchain/uClibc/uClibc-0.9.29-linuxthreads.patch
new file mode 100644
index 000000000..8ce2439b4
--- /dev/null
+++ b/toolchain/uClibc/uClibc-0.9.29-linuxthreads.patch
@@ -0,0 +1,145 @@
+--- 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
+