1 /* Smoke testing GDB process attach with thread-local variable access.
2 Copyright (C) 2021-2023 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
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 <https://www.gnu.org/licenses/>. */
18
19 /* This test runs GDB against a forked copy of itself, to check
20 whether libthread_db can be loaded, and that access to thread-local
21 variables works. */
22
23 #include <elf.h>
24 #include <errno.h>
25 #include <fcntl.h>
26 #include <signal.h>
27 #include <stdbool.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <support/capture_subprocess.h>
31 #include <support/check.h>
32 #include <support/xptrace.h>
33 #include <support/subprocess.h>
34 #include <support/support.h>
35 #include <support/temp_file.h>
36 #include <support/test-driver.h>
37 #include <support/xstdio.h>
38 #include <support/xthread.h>
39 #include <support/xunistd.h>
40 #include <unistd.h>
41
42 /* Starts out as zero, changed to 1 or 2 by the debugger, depending on
43 the thread. */
44 __thread volatile int altered_by_debugger;
45
46 /* Common prefix between 32-bit and 64-bit ELF. */
47 struct elf_prefix
48 {
49 unsigned char e_ident[EI_NIDENT];
50 uint16_t e_type;
51 uint16_t e_machine;
52 uint32_t e_version;
53 };
54 _Static_assert (sizeof (struct elf_prefix) == EI_NIDENT + 8,
55 "padding in struct elf_prefix");
56
57 /* Reads the ELF header from PATH. Returns true if the header can be
58 read, false if the file is too short. */
59 static bool
60 read_elf_header (const char *path, struct elf_prefix *elf)
61 {
62 int fd = xopen (path, O_RDONLY, 0);
63 bool result = read (fd, elf, sizeof (*elf)) == sizeof (*elf);
64 xclose (fd);
65 return result;
66 }
67
68 /* Searches for "gdb" alongside the path variable. See execvpe. */
69 static char *
70 find_gdb (void)
71 {
72 const char *path = getenv ("PATH");
73 if (path == NULL)
74 return NULL;
75 while (true)
76 {
77 const char *colon = strchrnul (path, ':');
78 char *candidate = xasprintf ("%.*s/gdb", (int) (colon - path), path);
79 if (access (candidate, X_OK) == 0)
80 return candidate;
81 free (candidate);
82 if (*colon == '\0')
83 break;
84 path = colon + 1;
85 }
86 return NULL;
87 }
88
89 /* Writes the GDB script to run the test to PATH. */
90 static void
91 write_gdbscript (const char *path, int tested_pid)
92 {
93 FILE *fp = xfopen (path, "w");
94 fprintf (fp,
95 "set trace-commands on\n"
96 "set debug libthread-db 1\n"
97 #if DO_ADD_SYMBOL_FILE
98 /* Do not do this unconditionally to work around a GDB
99 assertion failure: ../../gdb/symtab.c:6404:
100 internal-error: CORE_ADDR get_msymbol_address(objfile*,
101 const minimal_symbol*): Assertion `(objf->flags &
102 OBJF_MAINLINE) == 0' failed. */
103 "add-symbol-file %1$s/nptl/tst-pthread-gdb-attach\n"
104 #endif
105 "set auto-load safe-path %1$s/nptl_db\n"
106 "set libthread-db-search-path %1$s/nptl_db\n"
107 "attach %2$d\n",
108 support_objdir_root, tested_pid);
109 fputs ("break debugger_inspection_point\n"
110 "continue\n"
111 "thread 1\n"
112 "print altered_by_debugger\n"
113 "print altered_by_debugger = 1\n"
114 "thread 2\n"
115 "print altered_by_debugger\n"
116 "print altered_by_debugger = 2\n"
117 "continue\n",
118 fp);
119 xfclose (fp);
120 }
121
122 /* The test sets a breakpoint on this function and alters the
123 altered_by_debugger thread-local variable. */
124 void __attribute__ ((weak))
125 debugger_inspection_point (void)
126 {
127 }
128
129 /* Thread function for the test thread in the subprocess. */
130 static void *
131 subprocess_thread (void *closure)
132 {
133 /* Wait until altered_by_debugger changes the value away from 0. */
134 while (altered_by_debugger == 0)
135 {
136 usleep (100 * 1000);
137 debugger_inspection_point ();
138 }
139
140 TEST_COMPARE (altered_by_debugger, 2);
141 return NULL;
142 }
143
144 /* This function implements the subprocess under test. It creates a
145 second thread, waiting for its value to change to 2, and checks
146 that the main thread also changed its value to 1. */
147 static void
148 in_subprocess (void *arg)
149 {
150 pthread_t thr = xpthread_create (NULL, subprocess_thread, NULL);
151 TEST_VERIFY (xpthread_join (thr) == NULL);
152 TEST_COMPARE (altered_by_debugger, 1);
153 _exit (0);
154 }
155
156 static void
157 gdb_process (const char *gdb_path, const char *gdbscript, pid_t *tested_pid)
158 {
159 /* Create a copy of current test to check with gdb. As the
160 target_process is a child of this gdb_process, gdb is also able
161 to attach to target_process if YAMA is configured to 1 =
162 "restricted ptrace". */
163 struct support_subprocess target = support_subprocess (in_subprocess, NULL);
164
165 write_gdbscript (gdbscript, target.pid);
166 *tested_pid = target.pid;
167
168 xdup2 (STDOUT_FILENO, STDERR_FILENO);
169 execl (gdb_path, "gdb", "-nx", "-batch", "-x", gdbscript, NULL);
170 if (errno == ENOENT)
171 _exit (EXIT_UNSUPPORTED);
172 else
173 _exit (1);
174 }
175
176 static int
177 do_test (void)
178 {
179 char *gdb_path = find_gdb ();
180 if (gdb_path == NULL)
181 FAIL_UNSUPPORTED ("gdb command not found in PATH: %s", getenv ("PATH"));
182
183 /* Check that libthread_db is compatible with the gdb architecture
184 because gdb loads it via dlopen. */
185 {
186 char *threaddb_path = xasprintf ("%s/nptl_db/libthread_db.so",
187 support_objdir_root);
188 struct elf_prefix elf_threaddb;
189 TEST_VERIFY_EXIT (read_elf_header (threaddb_path, &elf_threaddb));
190 struct elf_prefix elf_gdb;
191 /* If the ELF header cannot be read or "gdb" is not an ELF file,
192 assume this is a wrapper script that can run. */
193 if (read_elf_header (gdb_path, &elf_gdb)
194 && memcmp (&elf_gdb, ELFMAG, SELFMAG) == 0)
195 {
196 if (elf_gdb.e_ident[EI_CLASS] != elf_threaddb.e_ident[EI_CLASS])
197 FAIL_UNSUPPORTED ("GDB at %s has wrong class", gdb_path);
198 if (elf_gdb.e_ident[EI_DATA] != elf_threaddb.e_ident[EI_DATA])
199 FAIL_UNSUPPORTED ("GDB at %s has wrong data", gdb_path);
200 if (elf_gdb.e_machine != elf_threaddb.e_machine)
201 FAIL_UNSUPPORTED ("GDB at %s has wrong machine", gdb_path);
202 }
203 free (threaddb_path);
204 }
205
206 /* Check if our subprocess can be debugged with ptrace. */
207 {
208 int ptrace_scope = support_ptrace_scope ();
209 if (ptrace_scope >= 2)
210 FAIL_UNSUPPORTED ("/proc/sys/kernel/yama/ptrace_scope >= 2");
211 }
212
213 char *gdbscript;
214 xclose (create_temp_file ("tst-pthread-gdb-attach-", &gdbscript));
215
216 /* Run 'gdb' on test subprocess which will be created in gdb_process.
217 The pid of the subprocess will be written to 'tested_pid'. */
218 pid_t *tested_pid = support_shared_allocate (sizeof (pid_t));
219
220 pid_t gdb_pid = xfork ();
221 if (gdb_pid == 0)
222 gdb_process (gdb_path, gdbscript, tested_pid);
223
224 int status;
225 TEST_COMPARE (xwaitpid (gdb_pid, &status, 0), gdb_pid);
226 if (WIFEXITED (status) && WEXITSTATUS (status) == EXIT_UNSUPPORTED)
227 /* gdb is not installed. */
228 return EXIT_UNSUPPORTED;
229 TEST_COMPARE (status, 0);
230
231 kill (*tested_pid, SIGKILL);
232
233 support_shared_free (tested_pid);
234 free (gdbscript);
235 free (gdb_path);
236 return 0;
237 }
238
239 #include <support/test-driver.c>