elf/pldd.c

   1 /* List dynamic shared objects linked into given process.
   2    Copyright (C) 2011, 2012 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@gmail.com>, 2011.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include <alloca.h>
  21 #include <argp.h>
  22 #include <assert.h>
  23 #include <dirent.h>
  24 #include <elf.h>
  25 #include <errno.h>
  26 #include <error.h>
  27 #include <fcntl.h>
  28 #include <libintl.h>
  29 #include <link.h>
  30 #include <stddef.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <unistd.h>
  35 #include <sys/ptrace.h>
  36 #include <sys/stat.h>
  37
  38 #include <ldsodefs.h>
  39 #include <version.h>
  40
  41 /* Global variables.  */
  42 extern char *program_invocation_short_name;
  43 #define PACKAGE _libc_intl_domainname
  44
  45 /* External functions.  */
  46 extern void *xmalloc (size_t n)
  47   __attribute_malloc__ __attribute_alloc_size (1);
  48 extern void *xrealloc (void *o, size_t n)
  49   __attribute_malloc__ __attribute_alloc_size (2);
  50
  51 /* Name and version of program.  */
  52 static void print_version (FILE *stream, struct argp_state *state);
  53 void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version;
  54
  55 /* Bug report address.  */
  56 const char *argp_program_bug_address = N_("\
  57 For bug reporting instructions, please see:\n\
  58 <http://www.gnu.org/software/libc/bugs.html>.\n");
  59
  60 /* Definitions of arguments for argp functions.  */
  61 static const struct argp_option options[] =
  62 {
  63   { NULL, 0, NULL, 0, NULL }
  64 };
  65
  66 /* Short description of program.  */
  67 static const char doc[] = N_("\
  68 List dynamic shared objects loaded into process.");
  69
  70 /* Strings for arguments in help texts.  */
  71 static const char args_doc[] = N_("PID");
  72
  73 /* Prototype for option handler.  */
  74 static error_t parse_opt (int key, char *arg, struct argp_state *state);
  75
  76 /* Data structure to communicate with argp functions.  */
  77 static struct argp argp =
  78 {
  79   options, parse_opt, args_doc, doc, NULL, NULL, NULL
  80 };
  81
  82 // File descriptor of /proc/*/mem file.
  83 static int memfd;
  84
  85 /* Name of the executable  */
  86 static char *exe;
  87
  88 /* Local functions.  */
  89 static int get_process_info (int dfd, long int pid);
  90
  91
  92 int
  93 main (int argc, char *argv[])
  94 {
  95   /* Parse and process arguments.  */
  96   int remaining;
  97   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
  98
  99   if (remaining != argc - 1)
 100     {
 101       fprintf (stderr,
 102                gettext ("Exactly one parameter with process ID required.\n"));
 103       argp_help (&argp, stderr, ARGP_HELP_SEE, program_invocation_short_name);
 104       return 1;
 105     }
 106
 107   assert (sizeof (pid_t) == sizeof (int)
 108           || sizeof (pid_t) == sizeof (long int));
 109   char *endp;
 110   errno = 0;
 111   long int pid = strtol (argv[remaining], &endp, 10);
 112   if (pid < 0 || (pid == ULONG_MAX && errno == ERANGE) || *endp != '\0'
 113       || (sizeof (pid_t) < sizeof (pid) && pid > INT_MAX))
 114     error (EXIT_FAILURE, 0, gettext ("invalid process ID '%s'"),
 115            argv[remaining]);
 116
 117   /* Determine the program name.  */
 118   char buf[7 + 3 * sizeof (pid)];
 119   snprintf (buf, sizeof (buf), "/proc/%lu", pid);
 120   int dfd = open (buf, O_RDONLY | O_DIRECTORY);
 121   if (dfd == -1)
 122     error (EXIT_FAILURE, errno, gettext ("cannot open %s"), buf);
 123
 124   size_t exesize = 1024;
 125 #ifdef PATH_MAX
 126   exesize = PATH_MAX;
 127 #endif
 128   exe = alloca (exesize);
 129   ssize_t nexe;
 130   while ((nexe = readlinkat (dfd, "exe", exe, exesize)) == exesize)
 131     extend_alloca (exe, exesize, 2 * exesize);
 132   if (nexe == -1)
 133     exe = (char *) "<program name undetermined>";
 134   else
 135     exe[nexe] = '\0';
 136
 137   /* Stop all threads since otherwise the list of loaded modules might
 138      change while we are reading it.  */
 139   struct thread_list
 140   {
 141     pid_t tid;
 142     struct thread_list *next;
 143   } *thread_list = NULL;
 144
 145   int taskfd = openat (dfd, "task", O_RDONLY | O_DIRECTORY | O_CLOEXEC);
 146   if (taskfd == 1)
 147     error (EXIT_FAILURE, errno, gettext ("cannot open %s/task"), buf);
 148   DIR *dir = fdopendir (taskfd);
 149   if (dir == NULL)
 150     error (EXIT_FAILURE, errno, gettext ("cannot prepare reading %s/task"),
 151            buf);
 152
 153   struct dirent64 *d;
 154   while ((d = readdir64 (dir)) != NULL)
 155     {
 156       if (! isdigit (d->d_name[0]))
 157         continue;
 158
 159       errno = 0;
 160       long int tid = strtol (d->d_name, &endp, 10);
 161       if (tid < 0 || (tid == ULONG_MAX && errno == ERANGE) || *endp != '\0'
 162           || (sizeof (pid_t) < sizeof (pid) && tid > INT_MAX))
 163         error (EXIT_FAILURE, 0, gettext ("invalid thread ID '%s'"),
 164                d->d_name);
 165
 166       if (ptrace (PTRACE_ATTACH, tid, NULL, NULL) != 0)
 167         {
 168           /* There might be a race between reading the directory and
 169              threads terminating.  Ignore errors attaching to unknown
 170              threads unless this is the main thread.  */
 171           if (errno == ESRCH && tid != pid)
 172             continue;
 173
 174           error (EXIT_FAILURE, errno, gettext ("cannot attach to process %lu"),
 175                  tid);
 176         }
 177
 178       struct thread_list *newp = alloca (sizeof (*newp));
 179       newp->tid = tid;
 180       newp->next = thread_list;
 181       thread_list = newp;
 182     }
 183
 184   closedir (dir);
 185
 186   int status = get_process_info (dfd, pid);
 187
 188   assert (thread_list != NULL);
 189   do
 190     {
 191       ptrace (PTRACE_DETACH, thread_list->tid, NULL, NULL);
 192       thread_list = thread_list->next;
 193     }
 194   while (thread_list != NULL);
 195
 196   close (dfd);
 197
 198   return status;
 199 }
 200
 201
 202 /* Handle program arguments.  */
 203 static error_t
 204 parse_opt (int key, char *arg, struct argp_state *state)
 205 {
 206   switch (key)
 207     {
 208     default:
 209       return ARGP_ERR_UNKNOWN;
 210     }
 211   return 0;
 212 }
 213
 214
 215 /* Print the version information.  */
 216 static void
 217 print_version (FILE *stream, struct argp_state *state)
 218 {
 219   fprintf (stream, "pldd (GNU %s) %s\n", PACKAGE, VERSION);
 220   fprintf (stream, gettext ("\
 221 Copyright (C) %s Free Software Foundation, Inc.\n\
 222 This is free software; see the source for copying conditions.  There is NO\n\
 223 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
 224 "), "2012");
 225   fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
 226 }
 227
 228
 229 #define CLASS 32
 230 #include "pldd-xx.c"
 231 #define CLASS 64
 232 #include "pldd-xx.c"
 233
 234
 235 static int
 236 get_process_info (int dfd, long int pid)
 237 {
 238   memfd = openat (dfd, "mem", O_RDONLY);
 239   if (memfd == -1)
 240     goto no_info;
 241
 242   int fd = openat (dfd, "exe", O_RDONLY);
 243   if (fd == -1)
 244     {
 245     no_info:
 246       error (0, errno, gettext ("cannot get information about process %lu"),
 247              pid);
 248       return EXIT_FAILURE;
 249     }
 250
 251   char e_ident[EI_NIDENT];
 252   if (read (fd, e_ident, EI_NIDENT) != EI_NIDENT)
 253     goto no_info;
 254
 255   close (fd);
 256
 257   if (memcmp (e_ident, ELFMAG, SELFMAG) != 0)
 258     {
 259       error (0, 0, gettext ("process %lu is no ELF program"), pid);
 260       return EXIT_FAILURE;
 261     }
 262
 263   fd = openat (dfd, "auxv", O_RDONLY);
 264   if (fd == -1)
 265     goto no_info;
 266
 267   size_t auxv_size = 0;
 268   void *auxv = NULL;
 269   while (1)
 270     {
 271       auxv_size += 512;
 272       auxv = xrealloc (auxv, auxv_size);
 273
 274       ssize_t n = pread (fd, auxv, auxv_size, 0);
 275       if (n < 0)
 276         goto no_info;
 277       if (n < auxv_size)
 278         {
 279           auxv_size = n;
 280           break;
 281         }
 282     }
 283
 284   close (fd);
 285
 286   int retval;
 287   if (e_ident[EI_CLASS] == ELFCLASS32)
 288     retval = find_maps32 (pid, auxv, auxv_size);
 289   else
 290     retval = find_maps64 (pid, auxv, auxv_size);
 291
 292   free (auxv);
 293   close (memfd);
 294
 295   return retval;
 296 }