1 /* List dynamic shared objects linked into given process.
2 Copyright (C) 2011-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 #define _FILE_OFFSET_BITS 64
20
21 #include <argp.h>
22 #include <dirent.h>
23 #include <error.h>
24 #include <fcntl.h>
25 #include <libintl.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <unistd.h>
29 #include <sys/ptrace.h>
30 #include <sys/wait.h>
31 #include <scratch_buffer.h>
32
33 #include <ldsodefs.h>
34 #include <version.h>
35
36 /* Global variables. */
37 extern char *program_invocation_short_name;
38 #define PACKAGE _libc_intl_domainname
39
40 /* External functions. */
41 #include <programs/xmalloc.h>
42
43 /* Name and version of program. */
44 static void print_version (FILE *stream, struct argp_state *state);
45 void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version;
46
47 /* Function to print some extra text in the help message. */
48 static char *more_help (int key, const char *text, void *input);
49
50 /* Definitions of arguments for argp functions. */
51 static const struct argp_option options[] =
52 {
53 { NULL, 0, NULL, 0, NULL }
54 };
55
56 /* Short description of program. */
57 static const char doc[] = N_("\
58 List dynamic shared objects loaded into process.");
59
60 /* Strings for arguments in help texts. */
61 static const char args_doc[] = N_("PID");
62
63 /* Prototype for option handler. */
64 static error_t parse_opt (int key, char *arg, struct argp_state *state);
65
66 /* Data structure to communicate with argp functions. */
67 static struct argp argp =
68 {
69 options, parse_opt, args_doc, doc, NULL, more_help, NULL
70 };
71
72
73 /* Local functions. */
74 static int get_process_info (const char *exe, int dfd, long int pid);
75 static void wait_for_ptrace_stop (long int pid);
76
77
78 int
79 main (int argc, char *argv[])
80 {
81 /* Parse and process arguments. */
82 int remaining;
83 argp_parse (&argp, argc, argv, 0, &remaining, NULL);
84
85 if (remaining != argc - 1)
86 {
87 fprintf (stderr,
88 gettext ("Exactly one parameter with process ID required.\n"));
89 argp_help (&argp, stderr, ARGP_HELP_SEE, program_invocation_short_name);
90 return 1;
91 }
92
93 _Static_assert (sizeof (pid_t) == sizeof (int)
94 || sizeof (pid_t) == sizeof (long int),
95 "sizeof (pid_t) != sizeof (int) or sizeof (long int)");
96
97 char *endp;
98 errno = 0;
99 long int pid = strtol (argv[remaining], &endp, 10);
100 if (pid < 0 || (pid == ULONG_MAX && errno == ERANGE) || *endp != '\0'
101 || (sizeof (pid_t) < sizeof (pid) && pid > INT_MAX))
102 error (EXIT_FAILURE, 0, gettext ("invalid process ID '%s'"),
103 argv[remaining]);
104
105 /* Determine the program name. */
106 char buf[7 + 3 * sizeof (pid)];
107 snprintf (buf, sizeof (buf), "/proc/%lu", pid);
108 int dfd = open (buf, O_RDONLY | O_DIRECTORY);
109 if (dfd == -1)
110 error (EXIT_FAILURE, errno, gettext ("cannot open %s"), buf);
111
112 /* Name of the executable */
113 struct scratch_buffer exe;
114 scratch_buffer_init (&exe);
115 ssize_t nexe;
116 while ((nexe = readlinkat (dfd, "exe",
117 exe.data, exe.length)) == exe.length)
118 {
119 if (!scratch_buffer_grow (&exe))
120 {
121 nexe = -1;
122 break;
123 }
124 }
125 if (nexe == -1)
126 /* Default stack allocation is at least 1024. */
127 snprintf (exe.data, exe.length, "<program name undetermined>");
128 else
129 ((char*)exe.data)[nexe] = '\0';
130
131 /* Stop all threads since otherwise the list of loaded modules might
132 change while we are reading it. */
133 struct thread_list
134 {
135 pid_t tid;
136 struct thread_list *next;
137 } *thread_list = NULL;
138
139 int taskfd = openat (dfd, "task", O_RDONLY | O_DIRECTORY | O_CLOEXEC);
140 if (taskfd == 1)
141 error (EXIT_FAILURE, errno, gettext ("cannot open %s/task"), buf);
142 DIR *dir = fdopendir (taskfd);
143 if (dir == NULL)
144 error (EXIT_FAILURE, errno, gettext ("cannot prepare reading %s/task"),
145 buf);
146
147 struct dirent *d;
148 while ((d = readdir (dir)) != NULL)
149 {
150 if (! isdigit (d->d_name[0]))
151 continue;
152
153 errno = 0;
154 long int tid = strtol (d->d_name, &endp, 10);
155 if (tid < 0 || (tid == ULONG_MAX && errno == ERANGE) || *endp != '\0'
156 || (sizeof (pid_t) < sizeof (pid) && tid > INT_MAX))
157 error (EXIT_FAILURE, 0, gettext ("invalid thread ID '%s'"),
158 d->d_name);
159
160 if (ptrace (PTRACE_ATTACH, tid, NULL, NULL) != 0)
161 {
162 /* There might be a race between reading the directory and
163 threads terminating. Ignore errors attaching to unknown
164 threads unless this is the main thread. */
165 if (errno == ESRCH && tid != pid)
166 continue;
167
168 error (EXIT_FAILURE, errno, gettext ("cannot attach to process %lu"),
169 tid);
170 }
171
172 wait_for_ptrace_stop (tid);
173
174 struct thread_list *newp = xmalloc (sizeof (*newp));
175 newp->tid = tid;
176 newp->next = thread_list;
177 thread_list = newp;
178 }
179
180 closedir (dir);
181
182 if (thread_list == NULL)
183 error (EXIT_FAILURE, 0, gettext ("no valid %s/task entries"), buf);
184
185 int status = get_process_info (exe.data, dfd, pid);
186
187 do
188 {
189 ptrace (PTRACE_DETACH, thread_list->tid, NULL, NULL);
190 struct thread_list *prev = thread_list;
191 thread_list = thread_list->next;
192 free (prev);
193 }
194 while (thread_list != NULL);
195
196 close (dfd);
197 scratch_buffer_free (&exe);
198
199 return status;
200 }
201
202
203 /* Wait for PID to enter ptrace-stop state after being attached. */
204 static void
205 wait_for_ptrace_stop (long int pid)
206 {
207 int status;
208
209 /* While waiting for SIGSTOP being delivered to the tracee we have to
210 reinject any other pending signal. Ignore all other errors. */
211 while (waitpid (pid, &status, __WALL) == pid && WIFSTOPPED (status))
212 {
213 /* The STOP signal should not be delivered to the tracee. */
214 if (WSTOPSIG (status) == SIGSTOP)
215 return;
216 if (ptrace (PTRACE_CONT, pid, NULL,
217 (void *) (uintptr_t) WSTOPSIG (status)))
218 /* The only possible error is that the process died. */
219 return;
220 }
221 }
222
223
224 /* Handle program arguments. */
225 static error_t
226 parse_opt (int key, char *arg, struct argp_state *state)
227 {
228 switch (key)
229 {
230 default:
231 return ARGP_ERR_UNKNOWN;
232 }
233 return 0;
234 }
235
236
237 /* Print bug-reporting information in the help message. */
238 static char *
239 more_help (int key, const char *text, void *input)
240 {
241 char *tp = NULL;
242 switch (key)
243 {
244 case ARGP_KEY_HELP_EXTRA:
245 /* We print some extra information. */
246 if (asprintf (&tp, gettext ("\
247 For bug reporting instructions, please see:\n\
248 %s.\n"), REPORT_BUGS_TO) < 0)
249 return NULL;
250 return tp;
251 default:
252 break;
253 }
254 return (char *) text;
255 }
256
257 /* Print the version information. */
258 static void
259 print_version (FILE *stream, struct argp_state *state)
260 {
261 fprintf (stream, "pldd %s%s\n", PKGVERSION, VERSION);
262 fprintf (stream, gettext ("\
263 Copyright (C) %s Free Software Foundation, Inc.\n\
264 This is free software; see the source for copying conditions. There is NO\n\
265 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
266 "), "2023");
267 fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
268 }
269
270
271 #define CLASS 32
272 #include "pldd-xx.c"
273 #define CLASS 64
274 #include "pldd-xx.c"
275
276
277 static int
278 get_process_info (const char *exe, int dfd, long int pid)
279 {
280 /* File descriptor of /proc/<pid>/mem file. */
281 int memfd = openat (dfd, "mem", O_RDONLY);
282 if (memfd == -1)
283 goto no_info;
284
285 int fd = openat (dfd, "exe", O_RDONLY);
286 if (fd == -1)
287 {
288 no_info:
289 error (0, errno, gettext ("cannot get information about process %lu"),
290 pid);
291 return EXIT_FAILURE;
292 }
293
294 char e_ident[EI_NIDENT];
295 if (read (fd, e_ident, EI_NIDENT) != EI_NIDENT)
296 goto no_info;
297
298 close (fd);
299
300 if (memcmp (e_ident, ELFMAG, SELFMAG) != 0)
301 {
302 error (0, 0, gettext ("process %lu is no ELF program"), pid);
303 return EXIT_FAILURE;
304 }
305
306 fd = openat (dfd, "auxv", O_RDONLY);
307 if (fd == -1)
308 goto no_info;
309
310 size_t auxv_size = 0;
311 void *auxv = NULL;
312 while (1)
313 {
314 auxv_size += 512;
315 auxv = xrealloc (auxv, auxv_size);
316
317 ssize_t n = pread (fd, auxv, auxv_size, 0);
318 if (n < 0)
319 goto no_info;
320 if (n < auxv_size)
321 {
322 auxv_size = n;
323 break;
324 }
325 }
326
327 close (fd);
328
329 int retval;
330 if (e_ident[EI_CLASS] == ELFCLASS32)
331 retval = find_maps32 (exe, memfd, pid, auxv, auxv_size);
332 else
333 retval = find_maps64 (exe, memfd, pid, auxv, auxv_size);
334
335 free (auxv);
336 close (memfd);
337
338 return retval;
339 }