1 /* Test that stack overflow and SIGSEGV are correctly distinguished.
2 Copyright (C) 2002-2021 Bruno Haible <bruno@clisp.org>
3 Copyright (C) 2010 Eric Blake <eblake@redhat.com>
4
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program 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
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <https://www.gnu.org/licenses/>. */
17
18 #include <config.h>
19
20 /* Specification. */
21 #include "sigsegv.h"
22
23 #include <stdint.h>
24 #include <stdio.h>
25 #include <limits.h>
26
27 #if HAVE_STACK_OVERFLOW_RECOVERY && HAVE_SIGSEGV_RECOVERY
28
29 # if defined _WIN32 && !defined __CYGWIN__
30 /* Windows doesn't have sigset_t. */
31 typedef int sigset_t;
32 # define sigemptyset(set)
33 # define sigprocmask(how,set,oldset)
34 # endif
35
36 # include "mmap-anon-util.h"
37 # include <stddef.h> /* needed for NULL on SunOS4 */
38 # include <stdlib.h> /* for abort, exit */
39 # include <signal.h>
40 # include <setjmp.h>
41 # if HAVE_SETRLIMIT
42 # include <sys/types.h>
43 # include <sys/time.h>
44 # include <sys/resource.h>
45 # endif
46 # include "altstack-util.h"
47
48 jmp_buf mainloop;
49 sigset_t mainsigset;
50
51 volatile int pass = 0;
52 uintptr_t page;
53
54 static void
55 stackoverflow_handler_continuation (void *arg1, void *arg2, void *arg3)
56 {
57 int arg = (int) (long) arg1;
58 longjmp (mainloop, arg);
59 }
60
61 void
62 stackoverflow_handler (int emergency, stackoverflow_context_t scp)
63 {
64 pass++;
65 if (pass <= 2)
66 printf ("Stack overflow %d caught.\n", pass);
67 else
68 {
69 printf ("Segmentation violation misdetected as stack overflow.\n");
70 exit (1);
71 }
72 sigprocmask (SIG_SETMASK, &mainsigset, NULL);
73 sigsegv_leave_handler (stackoverflow_handler_continuation,
74 (void *) (long) (emergency ? -1 : pass), NULL, NULL);
75 }
76
77 int
78 sigsegv_handler (void *address, int emergency)
79 {
80 /* This test is necessary to distinguish stack overflow and SIGSEGV. */
81 if (!emergency)
82 return 0;
83
84 pass++;
85 if (pass <= 2)
86 {
87 printf ("Stack overflow %d missed.\n", pass);
88 exit (1);
89 }
90 else
91 printf ("Segmentation violation correctly detected.\n");
92 sigprocmask (SIG_SETMASK, &mainsigset, NULL);
93 return sigsegv_leave_handler (stackoverflow_handler_continuation,
94 (void *) (long) pass, NULL, NULL);
95 }
96
97 volatile int *
98 recurse_1 (int n, volatile int *p)
99 {
100 if (n < INT_MAX)
101 *recurse_1 (n + 1, p) += n;
102 return p;
103 }
104
105 int
106 recurse (volatile int n)
107 {
108 return *recurse_1 (n, &n);
109 }
110
111 int
112 main ()
113 {
114 int prot_unwritable;
115 void *p;
116 sigset_t emptyset;
117
118 # if HAVE_SETRLIMIT && defined RLIMIT_STACK
119 /* Before starting the endless recursion, try to be friendly to the user's
120 machine. On some Linux 2.2.x systems, there is no stack limit for user
121 processes at all. We don't want to kill such systems. */
122 struct rlimit rl;
123 rl.rlim_cur = rl.rlim_max = 0x100000; /* 1 MB */
124 setrlimit (RLIMIT_STACK, &rl);
125 # endif
126
127 /* Prepare the storage for the alternate stack. */
128 prepare_alternate_stack ();
129
130 /* Install the stack overflow handler. */
131 if (stackoverflow_install_handler (&stackoverflow_handler,
132 mystack, MYSTACK_SIZE)
133 < 0)
134 exit (2);
135
136 /* Preparations. */
137 # if !HAVE_MAP_ANONYMOUS
138 zero_fd = open ("/dev/zero", O_RDONLY, 0644);
139 # endif
140
141 # if defined __linux__ && defined __sparc__
142 /* On Linux 2.6.26/SPARC64, PROT_READ has the same effect as
143 PROT_READ | PROT_WRITE. */
144 prot_unwritable = PROT_NONE;
145 # else
146 prot_unwritable = PROT_READ;
147 # endif
148
149 /* Setup some mmaped memory. */
150 p = mmap_zeromap ((void *) 0x12340000, 0x4000);
151 if (p == (void *)(-1))
152 {
153 fprintf (stderr, "mmap_zeromap failed.\n");
154 exit (2);
155 }
156 page = (uintptr_t) p;
157
158 /* Make it read-only. */
159 if (mprotect ((void *) page, 0x4000, prot_unwritable) < 0)
160 {
161 fprintf (stderr, "mprotect failed.\n");
162 exit (2);
163 }
164
165 /* Install the SIGSEGV handler. */
166 if (sigsegv_install_handler (&sigsegv_handler) < 0)
167 exit (2);
168
169 /* Save the current signal mask. */
170 sigemptyset (&emptyset);
171 sigprocmask (SIG_BLOCK, &emptyset, &mainsigset);
172
173 /* Provoke two stack overflows in a row. */
174 switch (setjmp (mainloop))
175 {
176 case -1:
177 printf ("emergency exit\n"); exit (1);
178 case 0: case 1:
179 printf ("Starting recursion pass %d.\n", pass + 1);
180 recurse (0);
181 printf ("no endless recursion?!\n"); exit (1);
182 case 2:
183 *(volatile int *) (page + 0x678) = 42;
184 break;
185 case 3:
186 *(volatile int *) 0 = 42;
187 break;
188 case 4:
189 break;
190 default:
191 abort ();
192 }
193
194 /* Validate that the alternate stack did not overflow. */
195 check_alternate_stack_no_overflow ();
196
197 printf ("Test passed.\n");
198 exit (0);
199 }
200
201 #else
202
203 int
204 main ()
205 {
206 return 77;
207 }
208
209 #endif