1 /* This testcase is part of GDB, the GNU debugger. 2 3 Copyright 2009-2016 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 #define _GNU_SOURCE 19 #include <pthread.h> 20 #include <stdio.h> 21 #include <limits.h> 22 #include <errno.h> 23 #include <stdlib.h> 24 #include <string.h> 25 #include <assert.h> 26 #include <sys/types.h> 27 #include <signal.h> 28 #include <unistd.h> 29 #include <asm/unistd.h> 30 31 #define gettid() syscall (__NR_gettid) 32 33 /* Terminate always in the main task, it can lock up with SIGSTOPped GDB 34 otherwise. */ 35 #define TIMEOUT (gettid () == getpid() ? 10 : 15) 36 37 static pid_t thread1_tid; 38 static pthread_cond_t thread1_tid_cond = PTHREAD_COND_INITIALIZER; 39 static pthread_mutex_t thread1_tid_mutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP; 40 41 static pid_t thread2_tid; 42 static pthread_cond_t thread2_tid_cond = PTHREAD_COND_INITIALIZER; 43 static pthread_mutex_t thread2_tid_mutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP; 44 45 static pthread_mutex_t terminate_mutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP; 46 47 static pthread_barrier_t threads_started_barrier; 48 49 /* These variables must have lower in-memory addresses than thread1_rwatch and 50 thread2_rwatch so that they take their watchpoint slots. */ 51 52 static int unused1_rwatch; 53 static int unused2_rwatch; 54 55 static volatile int thread1_rwatch; 56 static volatile int thread2_rwatch; 57 58 /* Do not use alarm as it would create a ptrace event which would hang up us if 59 we are being traced by GDB which we stopped ourselves. */ 60 61 static void timed_mutex_lock (pthread_mutex_t *mutex) 62 { 63 int i; 64 struct timespec start, now; 65 66 i = clock_gettime (CLOCK_MONOTONIC, &start); 67 assert (i == 0); 68 69 do 70 { 71 i = pthread_mutex_trylock (mutex); 72 if (i == 0) 73 return; 74 assert (i == EBUSY); 75 76 i = clock_gettime (CLOCK_MONOTONIC, &now); 77 assert (i == 0); 78 assert (now.tv_sec >= start.tv_sec); 79 } 80 while (now.tv_sec - start.tv_sec < TIMEOUT); 81 82 fprintf (stderr, "Timed out waiting for internal lock!\n"); 83 exit (EXIT_FAILURE); 84 } 85 86 static void * 87 thread1_func (void *unused) 88 { 89 int i; 90 volatile int rwatch_store; 91 92 pthread_barrier_wait (&threads_started_barrier); 93 94 timed_mutex_lock (&thread1_tid_mutex); 95 96 /* THREAD1_TID_MUTEX must be already locked to avoid race. */ 97 thread1_tid = gettid (); 98 99 i = pthread_cond_signal (&thread1_tid_cond); 100 assert (i == 0); 101 i = pthread_mutex_unlock (&thread1_tid_mutex); 102 assert (i == 0); 103 104 rwatch_store = thread1_rwatch; 105 106 /* Be sure the "t (tracing stop)" test can proceed for both threads. */ 107 timed_mutex_lock (&terminate_mutex); 108 i = pthread_mutex_unlock (&terminate_mutex); 109 assert (i == 0); 110 111 return NULL; 112 } 113 114 static void * 115 thread2_func (void *unused) 116 { 117 int i; 118 volatile int rwatch_store; 119 120 pthread_barrier_wait (&threads_started_barrier); 121 122 timed_mutex_lock (&thread2_tid_mutex); 123 124 /* THREAD2_TID_MUTEX must be already locked to avoid race. */ 125 thread2_tid = gettid (); 126 127 i = pthread_cond_signal (&thread2_tid_cond); 128 assert (i == 0); 129 i = pthread_mutex_unlock (&thread2_tid_mutex); 130 assert (i == 0); 131 132 rwatch_store = thread2_rwatch; 133 134 /* Be sure the "t (tracing stop)" test can proceed for both threads. */ 135 timed_mutex_lock (&terminate_mutex); 136 i = pthread_mutex_unlock (&terminate_mutex); 137 assert (i == 0); 138 139 return NULL; 140 } 141 142 static const char * 143 proc_string (const char *filename, const char *line) 144 { 145 FILE *f; 146 static char buf[LINE_MAX]; 147 size_t line_len = strlen (line); 148 149 f = fopen (filename, "r"); 150 if (f == NULL) 151 { 152 fprintf (stderr, "fopen (\"%s\") for \"%s\": %s\n", filename, line, 153 strerror (errno)); 154 exit (EXIT_FAILURE); 155 } 156 while (errno = 0, fgets (buf, sizeof (buf), f)) 157 { 158 char *s; 159 160 s = strchr (buf, '\n'); 161 assert (s != NULL); 162 *s = 0; 163 164 if (strncmp (buf, line, line_len) != 0) 165 continue; 166 167 if (fclose (f)) 168 { 169 fprintf (stderr, "fclose (\"%s\") for \"%s\": %s\n", filename, line, 170 strerror (errno)); 171 exit (EXIT_FAILURE); 172 } 173 174 return &buf[line_len]; 175 } 176 if (errno != 0) 177 { 178 fprintf (stderr, "fgets (\"%s\": %s\n", filename, strerror (errno)); 179 exit (EXIT_FAILURE); 180 } 181 fprintf (stderr, "\"%s\": No line \"%s\" found.\n", filename, line); 182 exit (EXIT_FAILURE); 183 } 184 185 static unsigned long 186 proc_ulong (const char *filename, const char *line) 187 { 188 const char *s = proc_string (filename, line); 189 long retval; 190 char *end; 191 192 errno = 0; 193 retval = strtol (s, &end, 10); 194 if (retval < 0 || retval >= LONG_MAX || (end && *end)) 195 { 196 fprintf (stderr, "\"%s\":\"%s\": %ld, %s\n", filename, line, retval, 197 strerror (errno)); 198 exit (EXIT_FAILURE); 199 } 200 return retval; 201 } 202 203 static void 204 state_wait (pid_t process, const char *wanted) 205 { 206 char *filename; 207 int i; 208 struct timespec start, now; 209 const char *state; 210 211 i = asprintf (&filename, "/proc/%lu/status", (unsigned long) process); 212 assert (i > 0); 213 214 i = clock_gettime (CLOCK_MONOTONIC, &start); 215 assert (i == 0); 216 217 do 218 { 219 state = proc_string (filename, "State:\t"); 220 221 /* torvalds/linux-2.6.git 464763cf1c6df632dccc8f2f4c7e50163154a2c0 222 has changed "T (tracing stop)" to "t (tracing stop)". Make the GDB 223 testcase backward compatible with older Linux kernels. */ 224 if (strcmp (state, "T (tracing stop)") == 0) 225 state = "t (tracing stop)"; 226 227 if (strcmp (state, wanted) == 0) 228 { 229 free (filename); 230 return; 231 } 232 233 if (sched_yield ()) 234 { 235 perror ("sched_yield()"); 236 exit (EXIT_FAILURE); 237 } 238 239 i = clock_gettime (CLOCK_MONOTONIC, &now); 240 assert (i == 0); 241 assert (now.tv_sec >= start.tv_sec); 242 } 243 while (now.tv_sec - start.tv_sec < TIMEOUT); 244 245 fprintf (stderr, "Timed out waiting for PID %lu \"%s\" (now it is \"%s\")!\n", 246 (unsigned long) process, wanted, state); 247 exit (EXIT_FAILURE); 248 } 249 250 static volatile pid_t tracer = 0; 251 static pthread_t thread1, thread2; 252 253 static void 254 cleanup (void) 255 { 256 printf ("Resuming GDB PID %lu.\n", (unsigned long) tracer); 257 258 if (tracer) 259 { 260 int i; 261 int tracer_save = tracer; 262 263 tracer = 0; 264 265 i = kill (tracer_save, SIGCONT); 266 assert (i == 0); 267 } 268 } 269 270 int 271 main (int argc, char **argv) 272 { 273 int i; 274 int standalone = 0; 275 276 if (argc == 2 && strcmp (argv[1], "-s") == 0) 277 standalone = 1; 278 else 279 assert (argc == 1); 280 281 setbuf (stdout, NULL); 282 283 timed_mutex_lock (&thread1_tid_mutex); 284 timed_mutex_lock (&thread2_tid_mutex); 285 286 timed_mutex_lock (&terminate_mutex); 287 288 pthread_barrier_init (&threads_started_barrier, NULL, 3); 289 290 i = pthread_create (&thread1, NULL, thread1_func, NULL); 291 assert (i == 0); 292 293 i = pthread_create (&thread2, NULL, thread2_func, NULL); 294 assert (i == 0); 295 296 if (!standalone) 297 { 298 tracer = proc_ulong ("/proc/self/status", "TracerPid:\t"); 299 if (tracer == 0) 300 { 301 fprintf (stderr, "The testcase must be run by GDB!\n"); 302 exit (EXIT_FAILURE); 303 } 304 if (tracer != getppid ()) 305 { 306 fprintf (stderr, "The testcase parent must be our GDB tracer!\n"); 307 exit (EXIT_FAILURE); 308 } 309 } 310 311 /* SIGCONT our debugger in the case of our crash as we would deadlock 312 otherwise. */ 313 314 atexit (cleanup); 315 316 /* Wait until all threads are seen running. On Linux (at least), 317 new threads start stopped, and the debugger must resume them. 318 Need to wait for that before stopping GDB. */ 319 pthread_barrier_wait (&threads_started_barrier); 320 321 printf ("Stopping GDB PID %lu.\n", (unsigned long) tracer); 322 323 if (tracer) 324 { 325 i = kill (tracer, SIGSTOP); 326 assert (i == 0); 327 state_wait (tracer, "T (stopped)"); 328 } 329 330 /* Threads are now waiting at timed_mutex_lock (thread1_tid_mutex) and so 331 they could not trigger the watchpoints before GDB gets unstopped later. 332 Threads get resumed at pthread_cond_wait below. Use `while' loops for 333 protection against spurious pthread_cond_wait wakeups. */ 334 335 printf ("Waiting till the threads initialize their TIDs.\n"); 336 337 while (thread1_tid == 0) 338 { 339 i = pthread_cond_wait (&thread1_tid_cond, &thread1_tid_mutex); 340 assert (i == 0); 341 } 342 343 while (thread2_tid == 0) 344 { 345 i = pthread_cond_wait (&thread2_tid_cond, &thread2_tid_mutex); 346 assert (i == 0); 347 } 348 349 printf ("Thread 1 TID = %lu, thread 2 TID = %lu, PID = %lu.\n", 350 (unsigned long) thread1_tid, (unsigned long) thread2_tid, 351 (unsigned long) getpid ()); 352 353 printf ("Waiting till the threads get trapped by the watchpoints.\n"); 354 355 if (tracer) 356 { 357 /* s390x-unknown-linux-gnu will fail with "R (running)". */ 358 359 state_wait (thread1_tid, "t (tracing stop)"); 360 361 state_wait (thread2_tid, "t (tracing stop)"); 362 } 363 364 cleanup (); 365 366 printf ("Joining the threads.\n"); 367 368 i = pthread_mutex_unlock (&terminate_mutex); 369 assert (i == 0); 370 371 i = pthread_join (thread1, NULL); 372 assert (i == 0); 373 374 i = pthread_join (thread2, NULL); 375 assert (i == 0); 376 377 printf ("Exiting.\n"); /* break-at-exit */ 378 379 /* Just prevent compiler `warning: unusedX_rwatch defined but not used'. */ 380 unused1_rwatch = 1; 381 unused2_rwatch = 2; 382 383 return EXIT_SUCCESS; 384 } 385