1 | /* Copyright (C) 2002-2016 Free Software Foundation, Inc. |
2 | This file is part of the GNU C Library. |
3 | Contributed by Ulrich Drepper <drepper@redhat.com>, 2002. |
4 | |
5 | The GNU C Library is free software; you can redistribute it and/or |
6 | modify it under the terms of the GNU Lesser General Public |
7 | License as published by the Free Software Foundation; either |
8 | version 2.1 of the License, or (at your option) any later version. |
9 | |
10 | The GNU C Library is distributed in the hope that it will be useful, |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Lesser General Public License for more details. |
14 | |
15 | You should have received a copy of the GNU Lesser General Public |
16 | License along with the GNU C Library; if not, see |
17 | <http://www.gnu.org/licenses/>. */ |
18 | |
19 | #include <assert.h> |
20 | #include <errno.h> |
21 | #include <inttypes.h> |
22 | #include <stdio.h> |
23 | #include <stdio_ext.h> |
24 | #include <stdlib.h> |
25 | #include <string.h> |
26 | #include <sys/resource.h> |
27 | #include "pthreadP.h" |
28 | #include <lowlevellock.h> |
29 | #include <ldsodefs.h> |
30 | |
31 | |
32 | int |
33 | pthread_getattr_np (pthread_t thread_id, pthread_attr_t *attr) |
34 | { |
35 | struct pthread *thread = (struct pthread *) thread_id; |
36 | struct pthread_attr *iattr = (struct pthread_attr *) attr; |
37 | int ret = 0; |
38 | |
39 | lll_lock (thread->lock, LLL_PRIVATE); |
40 | |
41 | /* The thread library is responsible for keeping the values in the |
42 | thread desriptor up-to-date in case the user changes them. */ |
43 | memcpy (&iattr->schedparam, &thread->schedparam, |
44 | sizeof (struct sched_param)); |
45 | iattr->schedpolicy = thread->schedpolicy; |
46 | |
47 | /* Clear the flags work. */ |
48 | iattr->flags = thread->flags; |
49 | |
50 | /* The thread might be detached by now. */ |
51 | if (IS_DETACHED (thread)) |
52 | iattr->flags |= ATTR_FLAG_DETACHSTATE; |
53 | |
54 | /* This is the guardsize after adjusting it. */ |
55 | iattr->guardsize = thread->reported_guardsize; |
56 | |
57 | /* The sizes are subject to alignment. */ |
58 | if (__glibc_likely (thread->stackblock != NULL)) |
59 | { |
60 | iattr->stacksize = thread->stackblock_size; |
61 | iattr->stackaddr = (char *) thread->stackblock + iattr->stacksize; |
62 | } |
63 | else |
64 | { |
65 | /* No stack information available. This must be for the initial |
66 | thread. Get the info in some magical way. */ |
67 | assert (abs (thread->pid) == thread->tid); |
68 | |
69 | /* Stack size limit. */ |
70 | struct rlimit rl; |
71 | |
72 | /* The safest way to get the top of the stack is to read |
73 | /proc/self/maps and locate the line into which |
74 | __libc_stack_end falls. */ |
75 | FILE *fp = fopen ("/proc/self/maps" , "rce" ); |
76 | if (fp == NULL) |
77 | ret = errno; |
78 | /* We need the limit of the stack in any case. */ |
79 | else |
80 | { |
81 | if (getrlimit (RLIMIT_STACK, &rl) != 0) |
82 | ret = errno; |
83 | else |
84 | { |
85 | /* We consider the main process stack to have ended with |
86 | the page containing __libc_stack_end. There is stuff below |
87 | it in the stack too, like the program arguments, environment |
88 | variables and auxv info, but we ignore those pages when |
89 | returning size so that the output is consistent when the |
90 | stack is marked executable due to a loaded DSO requiring |
91 | it. */ |
92 | void *stack_end = (void *) ((uintptr_t) __libc_stack_end |
93 | & -(uintptr_t) GLRO(dl_pagesize)); |
94 | #if _STACK_GROWS_DOWN |
95 | stack_end += GLRO(dl_pagesize); |
96 | #endif |
97 | /* We need no locking. */ |
98 | __fsetlocking (fp, FSETLOCKING_BYCALLER); |
99 | |
100 | /* Until we found an entry (which should always be the case) |
101 | mark the result as a failure. */ |
102 | ret = ENOENT; |
103 | |
104 | char *line = NULL; |
105 | size_t linelen = 0; |
106 | uintptr_t last_to = 0; |
107 | |
108 | while (! feof_unlocked (fp)) |
109 | { |
110 | if (__getdelim (&line, &linelen, '\n', fp) <= 0) |
111 | break; |
112 | |
113 | uintptr_t from; |
114 | uintptr_t to; |
115 | if (sscanf (line, "%" SCNxPTR "-%" SCNxPTR, &from, &to) != 2) |
116 | continue; |
117 | if (from <= (uintptr_t) __libc_stack_end |
118 | && (uintptr_t) __libc_stack_end < to) |
119 | { |
120 | /* Found the entry. Now we have the info we need. */ |
121 | iattr->stackaddr = stack_end; |
122 | iattr->stacksize = |
123 | rl.rlim_cur - (size_t) (to - (uintptr_t) stack_end); |
124 | |
125 | /* Cut it down to align it to page size since otherwise we |
126 | risk going beyond rlimit when the kernel rounds up the |
127 | stack extension request. */ |
128 | iattr->stacksize = (iattr->stacksize |
129 | & -(intptr_t) GLRO(dl_pagesize)); |
130 | |
131 | /* The limit might be too high. */ |
132 | if ((size_t) iattr->stacksize |
133 | > (size_t) iattr->stackaddr - last_to) |
134 | iattr->stacksize = (size_t) iattr->stackaddr - last_to; |
135 | |
136 | /* We succeed and no need to look further. */ |
137 | ret = 0; |
138 | break; |
139 | } |
140 | last_to = to; |
141 | } |
142 | |
143 | free (line); |
144 | } |
145 | |
146 | fclose (fp); |
147 | } |
148 | } |
149 | |
150 | iattr->flags |= ATTR_FLAG_STACKADDR; |
151 | |
152 | if (ret == 0) |
153 | { |
154 | size_t size = 16; |
155 | cpu_set_t *cpuset = NULL; |
156 | |
157 | do |
158 | { |
159 | size <<= 1; |
160 | |
161 | void *newp = realloc (cpuset, size); |
162 | if (newp == NULL) |
163 | { |
164 | ret = ENOMEM; |
165 | break; |
166 | } |
167 | cpuset = (cpu_set_t *) newp; |
168 | |
169 | ret = __pthread_getaffinity_np (thread_id, size, cpuset); |
170 | } |
171 | /* Pick some ridiculous upper limit. Is 8 million CPUs enough? */ |
172 | while (ret == EINVAL && size < 1024 * 1024); |
173 | |
174 | if (ret == 0) |
175 | { |
176 | iattr->cpuset = cpuset; |
177 | iattr->cpusetsize = size; |
178 | } |
179 | else |
180 | { |
181 | free (cpuset); |
182 | if (ret == ENOSYS) |
183 | { |
184 | /* There is no such functionality. */ |
185 | ret = 0; |
186 | iattr->cpuset = NULL; |
187 | iattr->cpusetsize = 0; |
188 | } |
189 | } |
190 | } |
191 | |
192 | lll_unlock (thread->lock, LLL_PRIVATE); |
193 | |
194 | return ret; |
195 | } |
196 | |