1 /* This testcase is part of GDB, the GNU debugger. 2 3 Copyright 2023 Free Software Foundation, Inc. 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 3 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 <http://www.gnu.org/licenses/>. */ 17 18 #include <pthread.h> 19 #include <assert.h> 20 #include <stdlib.h> 21 #include <signal.h> 22 #include <unistd.h> 23 24 /* The delay that the main thread gives once all the worker threads have 25 reached the barrier before the main thread enters the function on which 26 GDB will have placed a breakpoint. */ 27 28 #define MAIN_THREAD_DELAY 2 29 30 /* The maximum time we allow this test program to run for before an alarm 31 signal is sent and everything will exit. */ 32 #define WATCHDOG_ALARM_TIME 600 33 34 /* Aliases for the signals used within this script. Each signal 35 corresponds to an action (from the FINAL_ACTION enum) that the signal 36 handler will perform. */ 37 38 #define SPIN_SIGNAL SIGUSR1 39 #define SYSCALL_SIGNAL SIGUSR2 40 41 /* Describe the final action that a thread should perform. */ 42 43 enum final_action 44 { 45 /* Thread should spin in an infinite loop. */ 46 SPIN = 0, 47 48 /* Thread should block in a syscall. */ 49 SYSCALL, 50 51 /* This is just a marker to allow for looping over the enum. */ 52 LAST_ACTION 53 }; 54 55 /* Where should the thread perform this action? */ 56 57 enum exec_location 58 { 59 /* Just a normal thread, on a normal stack. */ 60 NORMAL = 0, 61 62 /* In a signal handler, but use the normal stack. */ 63 SIGNAL_HANDLER, 64 65 /* In a signal handler using an alternative stack. */ 66 SIGNAL_ALT_STACK, 67 68 /* This is just a marker to allow for looping over the enum. */ 69 LAST_LOCACTION 70 }; 71 72 /* A descriptor for a single thread job. We create a new thread for each 73 job_description. */ 74 75 struct job_description 76 { 77 /* What action should this thread perform. */ 78 enum final_action action; 79 80 /* Where should the thread perform the action. */ 81 enum exec_location location; 82 83 /* The actual thread handle, so we can join with the thread. */ 84 pthread_t thread; 85 }; 86 87 /* A pthread barrier, used to (try) and synchronise the threads. */ 88 pthread_barrier_t global_barrier; 89 90 /* Return a list of jobs, and place the length of the list in *COUNT. */ 91 92 struct job_description * 93 get_job_list (int *count) 94 { 95 /* The number of jobs. */ 96 int num = LAST_ACTION * LAST_LOCACTION; 97 98 /* The uninitialised array of jobs. */ 99 struct job_description *list 100 = malloc (num * sizeof (struct job_description)); 101 assert (list != NULL); 102 103 /* Fill the array with all possible jobs. */ 104 for (int i = 0; i < (int) LAST_ACTION; ++i) 105 for (int j = 0; j < (int) LAST_LOCACTION; ++j) 106 { 107 int idx = (i * LAST_LOCACTION) + j; 108 list[idx].action = (enum final_action) i; 109 list[idx].location = (enum exec_location) j; 110 } 111 112 /* Return the array of jobs. */ 113 *count = num; 114 return list; 115 } 116 117 /* This function should never be called. If it is then an assertion will 118 trigger. */ 119 120 void 121 assert_not_reached (void) 122 { 123 assert (0); 124 } 125 126 /* The function for a SPIN action. Just spins in a loop. The LOCATION 127 argument exists so GDB can identify the expected context for this 128 function. */ 129 130 void 131 do_spin_task (enum exec_location location) 132 { 133 (void) location; 134 135 /* Let everyone know that we're about to perform our action. */ 136 int res = pthread_barrier_wait (&global_barrier); 137 assert (res == PTHREAD_BARRIER_SERIAL_THREAD || res == 0); 138 139 while (1) 140 { 141 /* Nothing. */ 142 } 143 } 144 145 /* The function for a SYSCALL action. Just spins in a loop. The LOCATION 146 argument exists so GDB can identify the expected context for this 147 function. */ 148 149 void 150 do_syscall_task (enum exec_location location) 151 { 152 (void) location; 153 154 /* Let everyone know that we're about to perform our action. */ 155 int res = pthread_barrier_wait (&global_barrier); 156 assert (res == PTHREAD_BARRIER_SERIAL_THREAD || res == 0); 157 158 sleep (600); 159 } 160 161 /* Return the required size for a sigaltstack. We start with a single 162 page, but do check against the system defined minimums. We don't run 163 much on the alternative stacks, so we don't need a huge one. */ 164 165 size_t 166 get_stack_size (void) 167 { 168 size_t size = getpagesize (); /* Arbitrary starting size. */ 169 if (size < SIGSTKSZ) 170 size = SIGSTKSZ; 171 if (size < MINSIGSTKSZ) 172 size = MINSIGSTKSZ; 173 return size; 174 } 175 176 /* A descriptor for an alternative stack. */ 177 178 struct stack_descriptor 179 { 180 /* The base address of the alternative stack. This is the address that 181 must be freed to release the memory used by this stack. */ 182 void *base; 183 184 /* The size of this alternative stack. Tracked just so we can query this 185 from GDB. */ 186 size_t size; 187 }; 188 189 /* Install an alternative signal stack. Return a descriptor for the newly 190 allocated alternative stack. */ 191 192 struct stack_descriptor 193 setup_alt_stack (void) 194 { 195 size_t stack_size = get_stack_size (); 196 197 void *stack_area = malloc (stack_size); 198 199 stack_t stk; 200 stk.ss_sp = stack_area; 201 stk.ss_flags = 0; 202 stk.ss_size = stack_size; 203 204 int res = sigaltstack (&stk, NULL); 205 assert (res == 0); 206 207 struct stack_descriptor desc; 208 desc.base = stack_area; 209 desc.size = stack_size; 210 211 return desc; 212 } 213 214 /* Return true (non-zero) if we are currently on the alternative stack, 215 otherwise, return false (zero). */ 216 217 int 218 on_alt_stack_p (void) 219 { 220 stack_t stk; 221 int res = sigaltstack (NULL, &stk); 222 assert (res == 0); 223 224 return (stk.ss_flags & SS_ONSTACK) != 0; 225 } 226 227 /* The signal handler function. All signals call here, so we use SIGNO 228 (the signal that was delivered) to decide what action to perform. This 229 function might, or might not, have been called on an alternative signal 230 stack. */ 231 232 void 233 signal_handler (int signo) 234 { 235 enum exec_location location 236 = on_alt_stack_p () ? SIGNAL_ALT_STACK : SIGNAL_HANDLER; 237 238 switch (signo) 239 { 240 case SPIN_SIGNAL: 241 do_spin_task (location); 242 break; 243 244 case SYSCALL_SIGNAL: 245 do_syscall_task (location); 246 break; 247 248 default: 249 assert_not_reached (); 250 } 251 } 252 253 /* The thread worker function. ARG is a job_description pointer which 254 describes what this thread is expected to do. This function always 255 returns a NULL pointer. */ 256 257 void * 258 thread_function (void *arg) 259 { 260 struct job_description *job = (struct job_description *) arg; 261 struct stack_descriptor desc = { NULL, 0 }; 262 int sa_flags = 0; 263 264 switch (job->location) 265 { 266 case NORMAL: 267 /* This thread performs the worker action on the current thread, 268 select the correct worker function based on the requested 269 action. */ 270 switch (job->action) 271 { 272 case SPIN: 273 do_spin_task (NORMAL); 274 break; 275 276 case SYSCALL: 277 do_syscall_task (NORMAL); 278 break; 279 280 default: 281 assert_not_reached (); 282 } 283 break; 284 285 case SIGNAL_ALT_STACK: 286 /* This thread is to perform its action in a signal handler on the 287 alternative stack. Install the alternative stack now, and then 288 fall through to the normal signal handler location code. */ 289 desc = setup_alt_stack (); 290 assert (desc.base != NULL); 291 assert (desc.size > 0); 292 sa_flags = SA_ONSTACK; 293 294 /* Fall through. */ 295 case SIGNAL_HANDLER: 296 { 297 /* This thread is to perform its action in a signal handler. We 298 might have just installed an alternative signal stack. */ 299 int signo, res; 300 301 /* Select the correct signal number so that the signal handler will 302 perform the required action. */ 303 switch (job->action) 304 { 305 case SPIN: 306 signo = SPIN_SIGNAL; 307 break; 308 309 case SYSCALL: 310 signo = SYSCALL_SIGNAL; 311 break; 312 313 default: 314 assert_not_reached (); 315 } 316 317 /* Now setup the signal handler. */ 318 struct sigaction sa; 319 sa.sa_handler = signal_handler; 320 sigfillset (&sa.sa_mask); 321 sa.sa_flags = sa_flags; 322 res = sigaction (signo, &sa, NULL); 323 assert (res == 0); 324 325 /* Send the signal to this thread. */ 326 res = pthread_kill (job->thread, signo); 327 assert (res == 0); 328 } 329 break; 330 331 default: 332 assert_not_reached (); 333 }; 334 335 /* Free the alt-stack if we allocated one, if not DESC.BASE will be 336 NULL so this call is fine. */ 337 free (desc.base); 338 339 /* Thread complete. */ 340 return NULL; 341 } 342 343 void 344 start_job (struct job_description *job) 345 { 346 int res; 347 348 res = pthread_create (&job->thread, NULL, thread_function, job); 349 assert (res == 0); 350 } 351 352 /* Join with the thread for JOB. This will block until the thread for JOB 353 has finished. */ 354 355 void 356 finalise_job (struct job_description *job) 357 { 358 int res; 359 void *retval; 360 361 res = pthread_join (job->thread, &retval); 362 assert (res == 0); 363 assert (retval == NULL); 364 } 365 366 /* Function that GDB can place a breakpoint on. */ 367 368 void 369 breakpt (void) 370 { 371 /* Nothing. */ 372 } 373 374 /* Function that triggers a crash, if the user has setup their environment 375 correctly this will dump a core file, which GDB can then examine. */ 376 377 void 378 crash_function (void) 379 { 380 volatile int *p = 0; 381 volatile int n = *p; 382 (void) n; 383 } 384 385 /* Entry point. */ 386 387 int 388 main () 389 { 390 int job_count, res; 391 struct job_description *jobs = get_job_list (&job_count); 392 393 /* This test is going to park some threads inside infinite loops. Just 394 in case this program is left running, install an alarm that will cause 395 everything to exit. */ 396 alarm (WATCHDOG_ALARM_TIME); 397 398 /* We want each worker thread (of which there are JOB_COUNT) plus the 399 main thread (hence + 1) to wait at the barrier. */ 400 res = pthread_barrier_init (&global_barrier, NULL, job_count + 1); 401 assert (res == 0); 402 403 /* Start all the jobs. */ 404 for (int i = 0; i < job_count; ++i) 405 start_job (&jobs[i]); 406 407 /* Notify all the worker threads that we're waiting for them. */ 408 res = pthread_barrier_wait (&global_barrier); 409 assert (res == PTHREAD_BARRIER_SERIAL_THREAD || res == 0); 410 411 /* All we know at this point is that all the worker threads have reached 412 the barrier, which is just before they perform their action. But we 413 really want them to start their action. 414 415 There's really no way we can be 100% certain that the worker threads 416 have started their action, all we can do is wait for a short while and 417 hope that the machine we're running on is not too slow. */ 418 sleep (MAIN_THREAD_DELAY); 419 420 /* A function that GDB can place a breakpoint on. By the time we get 421 here we are as sure as we can be that all of the worker threads have 422 started and are in their worker action (spinning, or syscall). */ 423 breakpt (); 424 425 /* If GDB is not attached then this function will cause a crash, which 426 can be used to dump a core file, which GDB can then analyse. */ 427 crash_function (); 428 429 /* Due to the crash we never expect to get here. Plus the worker actions 430 never terminate. But for completeness, here's where we join with all 431 the worker threads. */ 432 for (int i = 0; i < job_count; ++i) 433 finalise_job (&jobs[i]); 434 435 /* Cleanup the barrier. */ 436 res = pthread_barrier_destroy (&global_barrier); 437 assert (res == 0); 438 439 /* And clean up the jobs list. */ 440 free (jobs); 441 442 return 0; 443 } 444
Indexes created Tue Mar 03 05:31:39 UTC 2026