| /* List dynamic shared objects linked into given process. |
| Copyright (C) 2011-2018 Free Software Foundation, Inc. |
| This file is part of the GNU C Library. |
| Contributed by Ulrich Drepper <drepper@gmail.com>, 2011. |
| |
| The GNU C Library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| The GNU C Library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with the GNU C Library; if not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include <alloca.h> |
| #include <argp.h> |
| #include <assert.h> |
| #include <dirent.h> |
| #include <elf.h> |
| #include <errno.h> |
| #include <error.h> |
| #include <fcntl.h> |
| #include <libintl.h> |
| #include <link.h> |
| #include <stddef.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <sys/ptrace.h> |
| #include <sys/stat.h> |
| #include <sys/wait.h> |
| #include <scratch_buffer.h> |
| |
| #include <ldsodefs.h> |
| #include <version.h> |
| |
| /* Global variables. */ |
| extern char *program_invocation_short_name; |
| #define PACKAGE _libc_intl_domainname |
| |
| /* External functions. */ |
| #include <programs/xmalloc.h> |
| |
| /* Name and version of program. */ |
| static void print_version (FILE *stream, struct argp_state *state); |
| void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version; |
| |
| /* Function to print some extra text in the help message. */ |
| static char *more_help (int key, const char *text, void *input); |
| |
| /* Definitions of arguments for argp functions. */ |
| static const struct argp_option options[] = |
| { |
| { NULL, 0, NULL, 0, NULL } |
| }; |
| |
| /* Short description of program. */ |
| static const char doc[] = N_("\ |
| List dynamic shared objects loaded into process."); |
| |
| /* Strings for arguments in help texts. */ |
| static const char args_doc[] = N_("PID"); |
| |
| /* Prototype for option handler. */ |
| static error_t parse_opt (int key, char *arg, struct argp_state *state); |
| |
| /* Data structure to communicate with argp functions. */ |
| static struct argp argp = |
| { |
| options, parse_opt, args_doc, doc, NULL, more_help, NULL |
| }; |
| |
| // File descriptor of /proc/*/mem file. |
| static int memfd; |
| |
| /* Name of the executable */ |
| static char *exe; |
| |
| /* Local functions. */ |
| static int get_process_info (int dfd, long int pid); |
| static void wait_for_ptrace_stop (long int pid); |
| |
| |
| int |
| main (int argc, char *argv[]) |
| { |
| /* Parse and process arguments. */ |
| int remaining; |
| argp_parse (&argp, argc, argv, 0, &remaining, NULL); |
| |
| if (remaining != argc - 1) |
| { |
| fprintf (stderr, |
| gettext ("Exactly one parameter with process ID required.\n")); |
| argp_help (&argp, stderr, ARGP_HELP_SEE, program_invocation_short_name); |
| return 1; |
| } |
| |
| assert (sizeof (pid_t) == sizeof (int) |
| || sizeof (pid_t) == sizeof (long int)); |
| char *endp; |
| errno = 0; |
| long int pid = strtol (argv[remaining], &endp, 10); |
| if (pid < 0 || (pid == ULONG_MAX && errno == ERANGE) || *endp != '\0' |
| || (sizeof (pid_t) < sizeof (pid) && pid > INT_MAX)) |
| error (EXIT_FAILURE, 0, gettext ("invalid process ID '%s'"), |
| argv[remaining]); |
| |
| /* Determine the program name. */ |
| char buf[7 + 3 * sizeof (pid)]; |
| snprintf (buf, sizeof (buf), "/proc/%lu", pid); |
| int dfd = open (buf, O_RDONLY | O_DIRECTORY); |
| if (dfd == -1) |
| error (EXIT_FAILURE, errno, gettext ("cannot open %s"), buf); |
| |
| struct scratch_buffer exebuf; |
| scratch_buffer_init (&exebuf); |
| ssize_t nexe; |
| while ((nexe = readlinkat (dfd, "exe", |
| exebuf.data, exebuf.length)) == exebuf.length) |
| { |
| if (!scratch_buffer_grow (&exebuf)) |
| { |
| nexe = -1; |
| break; |
| } |
| } |
| if (nexe == -1) |
| exe = (char *) "<program name undetermined>"; |
| else |
| { |
| exe = exebuf.data; |
| exe[nexe] = '\0'; |
| } |
| |
| /* Stop all threads since otherwise the list of loaded modules might |
| change while we are reading it. */ |
| struct thread_list |
| { |
| pid_t tid; |
| struct thread_list *next; |
| } *thread_list = NULL; |
| |
| int taskfd = openat (dfd, "task", O_RDONLY | O_DIRECTORY | O_CLOEXEC); |
| if (taskfd == 1) |
| error (EXIT_FAILURE, errno, gettext ("cannot open %s/task"), buf); |
| DIR *dir = fdopendir (taskfd); |
| if (dir == NULL) |
| error (EXIT_FAILURE, errno, gettext ("cannot prepare reading %s/task"), |
| buf); |
| |
| struct dirent64 *d; |
| while ((d = readdir64 (dir)) != NULL) |
| { |
| if (! isdigit (d->d_name[0])) |
| continue; |
| |
| errno = 0; |
| long int tid = strtol (d->d_name, &endp, 10); |
| if (tid < 0 || (tid == ULONG_MAX && errno == ERANGE) || *endp != '\0' |
| || (sizeof (pid_t) < sizeof (pid) && tid > INT_MAX)) |
| error (EXIT_FAILURE, 0, gettext ("invalid thread ID '%s'"), |
| d->d_name); |
| |
| if (ptrace (PTRACE_ATTACH, tid, NULL, NULL) != 0) |
| { |
| /* There might be a race between reading the directory and |
| threads terminating. Ignore errors attaching to unknown |
| threads unless this is the main thread. */ |
| if (errno == ESRCH && tid != pid) |
| continue; |
| |
| error (EXIT_FAILURE, errno, gettext ("cannot attach to process %lu"), |
| tid); |
| } |
| |
| wait_for_ptrace_stop (tid); |
| |
| struct thread_list *newp = alloca (sizeof (*newp)); |
| newp->tid = tid; |
| newp->next = thread_list; |
| thread_list = newp; |
| } |
| |
| closedir (dir); |
| |
| int status = get_process_info (dfd, pid); |
| |
| assert (thread_list != NULL); |
| do |
| { |
| ptrace (PTRACE_DETACH, thread_list->tid, NULL, NULL); |
| thread_list = thread_list->next; |
| } |
| while (thread_list != NULL); |
| |
| close (dfd); |
| |
| return status; |
| } |
| |
| |
| /* Wait for PID to enter ptrace-stop state after being attached. */ |
| static void |
| wait_for_ptrace_stop (long int pid) |
| { |
| int status; |
| |
| /* While waiting for SIGSTOP being delivered to the tracee we have to |
| reinject any other pending signal. Ignore all other errors. */ |
| while (waitpid (pid, &status, __WALL) == pid && WIFSTOPPED (status)) |
| { |
| /* The STOP signal should not be delivered to the tracee. */ |
| if (WSTOPSIG (status) == SIGSTOP) |
| return; |
| if (ptrace (PTRACE_CONT, pid, NULL, |
| (void *) (uintptr_t) WSTOPSIG (status))) |
| /* The only possible error is that the process died. */ |
| return; |
| } |
| } |
| |
| |
| /* Handle program arguments. */ |
| static error_t |
| parse_opt (int key, char *arg, struct argp_state *state) |
| { |
| switch (key) |
| { |
| default: |
| return ARGP_ERR_UNKNOWN; |
| } |
| return 0; |
| } |
| |
| |
| /* Print bug-reporting information in the help message. */ |
| static char * |
| more_help (int key, const char *text, void *input) |
| { |
| char *tp = NULL; |
| switch (key) |
| { |
| case ARGP_KEY_HELP_EXTRA: |
| /* We print some extra information. */ |
| if (asprintf (&tp, gettext ("\ |
| For bug reporting instructions, please see:\n\ |
| %s.\n"), REPORT_BUGS_TO) < 0) |
| return NULL; |
| return tp; |
| default: |
| break; |
| } |
| return (char *) text; |
| } |
| |
| /* Print the version information. */ |
| static void |
| print_version (FILE *stream, struct argp_state *state) |
| { |
| fprintf (stream, "pldd %s%s\n", PKGVERSION, VERSION); |
| fprintf (stream, gettext ("\ |
| Copyright (C) %s Free Software Foundation, Inc.\n\ |
| This is free software; see the source for copying conditions. There is NO\n\ |
| warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\ |
| "), "2018"); |
| fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper"); |
| } |
| |
| |
| #define CLASS 32 |
| #include "pldd-xx.c" |
| #define CLASS 64 |
| #include "pldd-xx.c" |
| |
| |
| static int |
| get_process_info (int dfd, long int pid) |
| { |
| memfd = openat (dfd, "mem", O_RDONLY); |
| if (memfd == -1) |
| goto no_info; |
| |
| int fd = openat (dfd, "exe", O_RDONLY); |
| if (fd == -1) |
| { |
| no_info: |
| error (0, errno, gettext ("cannot get information about process %lu"), |
| pid); |
| return EXIT_FAILURE; |
| } |
| |
| char e_ident[EI_NIDENT]; |
| if (read (fd, e_ident, EI_NIDENT) != EI_NIDENT) |
| goto no_info; |
| |
| close (fd); |
| |
| if (memcmp (e_ident, ELFMAG, SELFMAG) != 0) |
| { |
| error (0, 0, gettext ("process %lu is no ELF program"), pid); |
| return EXIT_FAILURE; |
| } |
| |
| fd = openat (dfd, "auxv", O_RDONLY); |
| if (fd == -1) |
| goto no_info; |
| |
| size_t auxv_size = 0; |
| void *auxv = NULL; |
| while (1) |
| { |
| auxv_size += 512; |
| auxv = xrealloc (auxv, auxv_size); |
| |
| ssize_t n = pread (fd, auxv, auxv_size, 0); |
| if (n < 0) |
| goto no_info; |
| if (n < auxv_size) |
| { |
| auxv_size = n; |
| break; |
| } |
| } |
| |
| close (fd); |
| |
| int retval; |
| if (e_ident[EI_CLASS] == ELFCLASS32) |
| retval = find_maps32 (pid, auxv, auxv_size); |
| else |
| retval = find_maps64 (pid, auxv, auxv_size); |
| |
| free (auxv); |
| close (memfd); |
| |
| return retval; |
| } |