|
yann@498
|
1 |
--- a/libpthread/linuxthreads.old/attr.c 2006-01-24 12:41:01.000000000 -0500
|
|
yann@498
|
2 |
+++ b/libpthread/linuxthreads.old/attr.c 2008-02-10 11:35:32.000000000 -0500
|
|
yann@498
|
3 |
@@ -25,6 +25,14 @@
|
|
yann@498
|
4 |
#include "pthread.h"
|
|
yann@498
|
5 |
#include "internals.h"
|
|
yann@498
|
6 |
|
|
yann@498
|
7 |
+#include <sys/resource.h>
|
|
yann@498
|
8 |
+#include <inttypes.h>
|
|
yann@498
|
9 |
+#include <stdio.h>
|
|
yann@498
|
10 |
+#include <stdio_ext.h>
|
|
yann@498
|
11 |
+#include <stdlib.h>
|
|
yann@498
|
12 |
+#include <sys/resource.h>
|
|
yann@498
|
13 |
+
|
|
yann@498
|
14 |
+
|
|
yann@498
|
15 |
/* NOTE: With uClibc I don't think we need this versioning stuff.
|
|
yann@498
|
16 |
* Therefore, define the function pthread_attr_init() here using
|
|
yann@498
|
17 |
* a strong symbol. */
|
|
yann@498
|
18 |
@@ -209,4 +217,94 @@ int __pthread_attr_getstacksize(const pt
|
|
yann@498
|
19 |
*stacksize = attr->__stacksize;
|
|
yann@498
|
20 |
return 0;
|
|
yann@498
|
21 |
}
|
|
yann@498
|
22 |
+
|
|
yann@498
|
23 |
+
|
|
yann@498
|
24 |
+extern int *__libc_stack_end;
|
|
yann@498
|
25 |
+
|
|
yann@498
|
26 |
weak_alias (__pthread_attr_getstacksize, pthread_attr_getstacksize)
|
|
yann@498
|
27 |
+void* pthread_getattr_np(pthread_t thread, pthread_attr_t *attr)
|
|
yann@498
|
28 |
+{
|
|
yann@498
|
29 |
+ static void *stackBase = 0;
|
|
yann@498
|
30 |
+ static size_t stackSize = 0;
|
|
yann@498
|
31 |
+ int ret = 0;
|
|
yann@498
|
32 |
+ /* Stack size limit. */
|
|
yann@498
|
33 |
+ struct rlimit rl;
|
|
yann@498
|
34 |
+
|
|
yann@498
|
35 |
+ /* The safest way to get the top of the stack is to read
|
|
yann@498
|
36 |
+ /proc/self/maps and locate the line into which
|
|
yann@498
|
37 |
+ __libc_stack_end falls. */
|
|
yann@498
|
38 |
+ FILE *fp = fopen("/proc/self/maps", "rc");
|
|
yann@498
|
39 |
+ if (fp == NULL)
|
|
yann@498
|
40 |
+ ret = errno;
|
|
yann@498
|
41 |
+ /* We need the limit of the stack in any case. */
|
|
yann@498
|
42 |
+ else if (getrlimit (RLIMIT_STACK, &rl) != 0)
|
|
yann@498
|
43 |
+ ret = errno;
|
|
yann@498
|
44 |
+ else {
|
|
yann@498
|
45 |
+ /* We need no locking. */
|
|
yann@498
|
46 |
+ __fsetlocking (fp, FSETLOCKING_BYCALLER);
|
|
yann@498
|
47 |
+
|
|
yann@498
|
48 |
+ /* Until we found an entry (which should always be the case)
|
|
yann@498
|
49 |
+ mark the result as a failure. */
|
|
yann@498
|
50 |
+ ret = ENOENT;
|
|
yann@498
|
51 |
+
|
|
yann@498
|
52 |
+ char *line = NULL;
|
|
yann@498
|
53 |
+ size_t linelen = 0;
|
|
yann@498
|
54 |
+ uintptr_t last_to = 0;
|
|
yann@498
|
55 |
+
|
|
yann@498
|
56 |
+ while (! feof_unlocked (fp)) {
|
|
yann@498
|
57 |
+ if (getdelim (&line, &linelen, '\n', fp) <= 0)
|
|
yann@498
|
58 |
+ break;
|
|
yann@498
|
59 |
+
|
|
yann@498
|
60 |
+ uintptr_t from;
|
|
yann@498
|
61 |
+ uintptr_t to;
|
|
yann@498
|
62 |
+ if (sscanf (line, "%x-%x", &from, &to) != 2)
|
|
yann@498
|
63 |
+ continue;
|
|
yann@498
|
64 |
+ if (from <= (uintptr_t) __libc_stack_end
|
|
yann@498
|
65 |
+ && (uintptr_t) __libc_stack_end < to) {
|
|
yann@498
|
66 |
+ /* Found the entry. Now we have the info we need. */
|
|
yann@498
|
67 |
+ attr->__stacksize = rl.rlim_cur;
|
|
yann@498
|
68 |
+#ifdef _STACK_GROWS_UP
|
|
yann@498
|
69 |
+ /* Don't check to enforce a limit on the __stacksize */
|
|
yann@498
|
70 |
+ attr->__stackaddr = (void *) from;
|
|
yann@498
|
71 |
+#else
|
|
yann@498
|
72 |
+ attr->__stackaddr = (void *) to;
|
|
yann@498
|
73 |
+
|
|
yann@498
|
74 |
+ /* The limit might be too high. */
|
|
yann@498
|
75 |
+ if ((size_t) attr->__stacksize > (size_t) attr->__stackaddr - last_to)
|
|
yann@498
|
76 |
+ attr->__stacksize = (size_t) attr->__stackaddr - last_to;
|
|
yann@498
|
77 |
+#endif
|
|
yann@498
|
78 |
+
|
|
yann@498
|
79 |
+ /* We succeed and no need to look further. */
|
|
yann@498
|
80 |
+ ret = 0;
|
|
yann@498
|
81 |
+ break;
|
|
yann@498
|
82 |
+ }
|
|
yann@498
|
83 |
+ last_to = to;
|
|
yann@498
|
84 |
+ }
|
|
yann@498
|
85 |
+
|
|
yann@498
|
86 |
+ fclose (fp);
|
|
yann@498
|
87 |
+ free (line);
|
|
yann@498
|
88 |
+ }
|
|
yann@498
|
89 |
+#ifndef _STACK_GROWS_UP
|
|
yann@498
|
90 |
+ stackBase = (char *) attr->__stackaddr - attr->__stacksize;
|
|
yann@498
|
91 |
+#else
|
|
yann@498
|
92 |
+ stackBase = attr->__stackaddr;
|
|
yann@498
|
93 |
+#endif
|
|
yann@498
|
94 |
+ stackSize = attr->__stacksize;
|
|
yann@498
|
95 |
+ return (void*)(stackBase + stackSize);
|
|
yann@498
|
96 |
+}
|
|
yann@498
|
97 |
+
|
|
yann@498
|
98 |
+int __pthread_attr_getstack (const pthread_attr_t *attr, void **stackaddr,
|
|
yann@498
|
99 |
+ size_t *stacksize)
|
|
yann@498
|
100 |
+{
|
|
yann@498
|
101 |
+ /* XXX This function has a stupid definition. The standard specifies
|
|
yann@498
|
102 |
+ no error value but what is if no stack address was set? We simply
|
|
yann@498
|
103 |
+ return the value we have in the member. */
|
|
yann@498
|
104 |
+#ifndef _STACK_GROWS_UP
|
|
yann@498
|
105 |
+ *stackaddr = (char *) attr->__stackaddr - attr->__stacksize;
|
|
yann@498
|
106 |
+#else
|
|
yann@498
|
107 |
+ *stackaddr = attr->__stackaddr;
|
|
yann@498
|
108 |
+#endif
|
|
yann@498
|
109 |
+ *stacksize = attr->__stacksize;
|
|
yann@498
|
110 |
+ return 0;
|
|
yann@498
|
111 |
+}
|
|
yann@498
|
112 |
+weak_alias (__pthread_attr_getstack, pthread_attr_getstack)
|
|
yann@498
|
113 |
|
|
yann@498
|
114 |
--- a/libpthread/linuxthreads.old/sysdeps/pthread/pthread.h 2006-12-07 22:19:36.000000000 -0500
|
|
yann@498
|
115 |
+++ b/libpthread/linuxthreads.old/sysdeps/pthread/pthread.h 2008-02-10 11:42:35.000000000 -0500
|
|
yann@498
|
116 |
@@ -288,15 +288,11 @@ extern int pthread_attr_getstacksize (__
|
|
yann@498
|
117 |
__attr, size_t *__restrict __stacksize)
|
|
yann@498
|
118 |
__THROW;
|
|
yann@498
|
119 |
|
|
yann@498
|
120 |
-#if 0
|
|
yann@498
|
121 |
-/* Not yet implemented in uClibc! */
|
|
yann@498
|
122 |
-
|
|
yann@498
|
123 |
#ifdef __USE_GNU
|
|
yann@498
|
124 |
/* Initialize thread attribute *ATTR with attributes corresponding to the
|
|
yann@498
|
125 |
already running thread TH. It shall be called on unitialized ATTR
|
|
yann@498
|
126 |
and destroyed with pthread_attr_destroy when no longer needed. */
|
|
yann@498
|
127 |
-extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) __THROW;
|
|
yann@498
|
128 |
-#endif
|
|
yann@498
|
129 |
+extern void* pthread_getattr_np(pthread_t thread, pthread_attr_t *attr);
|
|
yann@498
|
130 |
#endif
|
|
yann@498
|
131 |
|
|
yann@498
|
132 |
/* Functions for scheduling control. */
|
|
yann@498
|
133 |
@@ -599,6 +595,11 @@ extern int pthread_cancel (pthread_t __c
|
|
yann@498
|
134 |
cancelled. */
|
|
yann@498
|
135 |
extern void pthread_testcancel (void);
|
|
yann@498
|
136 |
|
|
yann@498
|
137 |
+/* Return the previously set address for the stack. */
|
|
yann@498
|
138 |
+extern int pthread_attr_getstack (__const pthread_attr_t *__restrict __attr,
|
|
yann@498
|
139 |
+ void **__restrict __stackaddr,
|
|
yann@498
|
140 |
+ size_t *__restrict __stacksize) __THROW;
|
|
yann@498
|
141 |
+
|
|
yann@498
|
142 |
|
|
yann@498
|
143 |
/* Install a cleanup handler: ROUTINE will be called with arguments ARG
|
|
yann@498
|
144 |
when the thread is cancelled or calls pthread_exit. ROUTINE will also
|
|
yann@498
|
145 |
|