1 | /* Make sure that the stackaddr returned by pthread_getattr_np is |
2 | reachable. |
3 | |
4 | Copyright (C) 2012-2022 Free Software Foundation, Inc. |
5 | This file is part of the GNU C Library. |
6 | |
7 | The GNU C Library is free software; you can redistribute it and/or |
8 | modify it under the terms of the GNU Lesser General Public |
9 | License as published by the Free Software Foundation; either |
10 | version 2.1 of the License, or (at your option) any later version. |
11 | |
12 | The GNU C Library is distributed in the hope that it will be useful, |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
15 | Lesser General Public License for more details. |
16 | |
17 | You should have received a copy of the GNU Lesser General Public |
18 | License along with the GNU C Library; if not, see |
19 | <https://www.gnu.org/licenses/>. */ |
20 | |
21 | #include <stdio.h> |
22 | #include <string.h> |
23 | #include <sys/resource.h> |
24 | #include <sys/param.h> |
25 | #include <pthread.h> |
26 | #include <alloca.h> |
27 | #include <assert.h> |
28 | #include <unistd.h> |
29 | #include <inttypes.h> |
30 | |
31 | #include <support/support.h> |
32 | |
33 | /* There is an obscure bug in the kernel due to which RLIMIT_STACK is sometimes |
34 | returned as unlimited when it is not, which may cause this test to fail. |
35 | There is also the other case where RLIMIT_STACK is intentionally set as |
36 | unlimited or very high, which may result in a vma that is too large and again |
37 | results in a test case failure. To avoid these problems, we cap the stack |
38 | size to one less than 8M. See the following mailing list threads for more |
39 | information about this problem: |
40 | <https://sourceware.org/ml/libc-alpha/2012-06/msg00599.html> |
41 | <https://sourceware.org/ml/libc-alpha/2012-06/msg00713.html>. */ |
42 | #define MAX_STACK_SIZE (8192 * 1024 - 1) |
43 | |
44 | static size_t pagesize; |
45 | |
46 | /* Test that the page in which TARGET lies is accessible. This will |
47 | segfault if the write fails. This function has only half a page |
48 | of thread stack left and so should not do anything and immediately |
49 | return the address to which the stack reached. */ |
50 | static volatile uintptr_t |
51 | allocate_and_test (char *target) |
52 | { |
53 | volatile char *mem = (char *) &mem; |
54 | /* FIXME: mem >= target for _STACK_GROWSUP. */ |
55 | mem = alloca ((size_t) (mem - target)); |
56 | |
57 | *mem = 42; |
58 | return (uintptr_t) mem; |
59 | } |
60 | |
61 | static int |
62 | get_self_pthread_attr (const char *id, void **stackaddr, size_t *stacksize) |
63 | { |
64 | pthread_attr_t attr; |
65 | int ret; |
66 | pthread_t me = pthread_self (); |
67 | |
68 | if ((ret = pthread_getattr_np (th: me, attr: &attr)) < 0) |
69 | { |
70 | printf (format: "%s: pthread_getattr_np failed: %s\n" , id, strerror (errnum: ret)); |
71 | return 1; |
72 | } |
73 | |
74 | if ((ret = pthread_attr_getstack (attr: &attr, stackaddr: stackaddr, stacksize: stacksize)) < 0) |
75 | { |
76 | printf (format: "%s: pthread_attr_getstack returned error: %s\n" , id, |
77 | strerror (errnum: ret)); |
78 | return 1; |
79 | } |
80 | |
81 | return 0; |
82 | } |
83 | |
84 | /* Verify that the stack size returned by pthread_getattr_np is usable when |
85 | the returned value is subject to rlimit. */ |
86 | static int |
87 | check_stack_top (void) |
88 | { |
89 | struct rlimit stack_limit; |
90 | void *stackaddr; |
91 | size_t stacksize = 0; |
92 | int ret; |
93 | uintptr_t pagemask = ~(pagesize - 1); |
94 | |
95 | puts (s: "Verifying that stack top is accessible" ); |
96 | |
97 | ret = getrlimit (RLIMIT_STACK, rlimits: &stack_limit); |
98 | if (ret) |
99 | { |
100 | perror ("getrlimit failed" ); |
101 | return 1; |
102 | } |
103 | |
104 | printf (format: "current rlimit_stack is %zu\n" , (size_t) stack_limit.rlim_cur); |
105 | |
106 | if (get_self_pthread_attr (id: "check_stack_top" , stackaddr: &stackaddr, stacksize: &stacksize)) |
107 | return 1; |
108 | |
109 | /* Reduce the rlimit to a page less that what is currently being returned |
110 | (subject to a maximum of MAX_STACK_SIZE) so that we ensure that |
111 | pthread_getattr_np uses rlimit. The figure is intentionally unaligned so |
112 | to verify that pthread_getattr_np returns an aligned stacksize that |
113 | correctly fits into the rlimit. We don't bother about the case where the |
114 | stack is limited by the vma below it and not by the rlimit because the |
115 | stacksize returned in that case is computed from the end of that vma and is |
116 | hence safe. */ |
117 | stack_limit.rlim_cur = MIN (stacksize - pagesize + 1, MAX_STACK_SIZE); |
118 | printf (format: "Adjusting RLIMIT_STACK to %zu\n" , (size_t) stack_limit.rlim_cur); |
119 | if ((ret = setrlimit (RLIMIT_STACK, rlimits: &stack_limit)) < 0) |
120 | { |
121 | perror ("setrlimit failed" ); |
122 | return 1; |
123 | } |
124 | |
125 | if (get_self_pthread_attr (id: "check_stack_top2" , stackaddr: &stackaddr, stacksize: &stacksize)) |
126 | return 1; |
127 | |
128 | printf (format: "Adjusted rlimit: stacksize=%zu, stackaddr=%p\n" , stacksize, |
129 | stackaddr); |
130 | |
131 | /* A lot of targets tend to write stuff on top of the user stack during |
132 | context switches, so we cannot possibly safely go up to the very top of |
133 | stack and test access there. It is however sufficient to simply check if |
134 | the top page is accessible, so we target our access halfway up the top |
135 | page. Thanks Chris Metcalf for this idea. */ |
136 | uintptr_t mem = allocate_and_test (target: stackaddr + pagesize / 2); |
137 | |
138 | /* Before we celebrate, make sure we actually did test the same page. */ |
139 | if (((uintptr_t) stackaddr & pagemask) != (mem & pagemask)) |
140 | { |
141 | printf (format: "We successfully wrote into the wrong page.\n" |
142 | "Expected %#" PRIxPTR ", but got %#" PRIxPTR "\n" , |
143 | (uintptr_t) stackaddr & pagemask, mem & pagemask); |
144 | |
145 | return 1; |
146 | } |
147 | |
148 | puts (s: "Stack top tests done" ); |
149 | |
150 | return 0; |
151 | } |
152 | |
153 | /* TODO: Similar check for thread stacks once the thread stack sizes are |
154 | fixed. */ |
155 | static int |
156 | do_test (void) |
157 | { |
158 | support_need_proc (why_msg: "Reads /proc/self/maps to get stack size." ); |
159 | |
160 | pagesize = sysconf (_SC_PAGESIZE); |
161 | return check_stack_top (); |
162 | } |
163 | |
164 | |
165 | #define TEST_FUNCTION do_test () |
166 | #include "../test-skeleton.c" |
167 | |