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
32int
33pthread_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