gdb/linux-proc.c

   1 /* GNU/Linux specific methods for using the /proc file system.
   2
   3    Copyright 2001, 2002 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "inferior.h"
  24 #include <sys/param.h>          /* for MAXPATHLEN */
  25 #include <sys/procfs.h>         /* for elf_gregset etc. */
  26 #include "gdb_stat.h"           /* for struct stat */
  27 #include <ctype.h>              /* for isdigit */
  28 #include <unistd.h>             /* for open, pread64 */
  29 #include <fcntl.h>              /* for O_RDONLY */
  30 #include "regcache.h"           /* for registers_changed */
  31 #include "gregset.h"            /* for gregset */
  32 #include "gdbcore.h"            /* for get_exec_file */
  33 #include "gdbthread.h"          /* for struct thread_info etc. */
  34 #include "elf-bfd.h"            /* for elfcore_write_* */
  35 #include "cli/cli-decode.h"     /* for add_info */
  36 #include "gdb_string.h"
  37
  38 #include "linux-nat.h"
  39
  40 #ifndef O_LARGEFILE
  41 #define O_LARGEFILE 0
  42 #endif
  43
  44 /* Function: child_pid_to_exec_file
  45  *
  46  * Accepts an integer pid
  47  * Returns a string representing a file that can be opened
  48  * to get the symbols for the child process.
  49  */
  50
  51 char *
  52 child_pid_to_exec_file (int pid)
  53 {
  54   char *name1, *name2;
  55
  56   name1 = xmalloc (MAXPATHLEN);
  57   name2 = xmalloc (MAXPATHLEN);
  58   make_cleanup (xfree, name1);
  59   make_cleanup (xfree, name2);
  60   memset (name2, 0, MAXPATHLEN);
  61
  62   sprintf (name1, "/proc/%d/exe", pid);
  63   if (readlink (name1, name2, MAXPATHLEN) > 0)
  64     return name2;
  65   else
  66     return name1;
  67 }
  68
  69 /* Function: read_mappings
  70  *
  71  * Service function for corefiles and info proc.
  72  */
  73
  74 static int
  75 read_mapping (FILE *mapfile,
  76               long long *addr,
  77               long long *endaddr,
  78               char *permissions,
  79               long long *offset,
  80               char *device, long long *inode, char *filename)
  81 {
  82   int ret = fscanf (mapfile, "%llx-%llx %s %llx %s %llx",
  83                     addr, endaddr, permissions, offset, device, inode);
  84
  85   if (ret > 0 && ret != EOF && *inode != 0)
  86     {
  87       /* Eat everything up to EOL for the filename.  This will prevent
  88          weird filenames (such as one with embedded whitespace) from
  89          confusing this code.  It also makes this code more robust
  90          in respect to annotations the kernel may add after the
  91          filename.
  92
  93          Note the filename is used for informational purposes only.  */
  94       ret += fscanf (mapfile, "%[^\n]\n", filename);
  95     }
  96   else
  97     {
  98       filename[0] = '\0';       /* no filename */
  99       fscanf (mapfile, "\n");
 100     }
 101   return (ret != 0 && ret != EOF);
 102 }
 103
 104 /* Function: linux_find_memory_regions
 105  *
 106  * Fills the "to_find_memory_regions" target vector.
 107  * Lists the memory regions in the inferior for a corefile.
 108  */
 109
 110 static int
 111 linux_find_memory_regions (int (*func) (CORE_ADDR,
 112                                         unsigned long,
 113                                         int, int, int, void *), void *obfd)
 114 {
 115   long long pid = PIDGET (inferior_ptid);
 116   char mapsfilename[MAXPATHLEN];
 117   FILE *mapsfile;
 118   long long addr, endaddr, size, offset, inode;
 119   char permissions[8], device[8], filename[MAXPATHLEN];
 120   int read, write, exec;
 121   int ret;
 122
 123   /* Compose the filename for the /proc memory map, and open it. */
 124   sprintf (mapsfilename, "/proc/%lld/maps", pid);
 125   if ((mapsfile = fopen (mapsfilename, "r")) == NULL)
 126     error ("Could not open %s\n", mapsfilename);
 127
 128   if (info_verbose)
 129     fprintf_filtered (gdb_stdout,
 130                       "Reading memory regions from %s\n", mapsfilename);
 131
 132   /* Now iterate until end-of-file. */
 133   while (read_mapping (mapsfile, &addr, &endaddr, &permissions[0],
 134                        &offset, &device[0], &inode, &filename[0]))
 135     {
 136       size = endaddr - addr;
 137
 138       /* Get the segment's permissions.  */
 139       read = (strchr (permissions, 'r') != 0);
 140       write = (strchr (permissions, 'w') != 0);
 141       exec = (strchr (permissions, 'x') != 0);
 142
 143       if (info_verbose)
 144         {
 145           fprintf_filtered (gdb_stdout,
 146                             "Save segment, %lld bytes at 0x%s (%c%c%c)",
 147                             size, paddr_nz (addr),
 148                             read ? 'r' : ' ',
 149                             write ? 'w' : ' ', exec ? 'x' : ' ');
 150           if (filename && filename[0])
 151             fprintf_filtered (gdb_stdout, " for %s", filename);
 152           fprintf_filtered (gdb_stdout, "\n");
 153         }
 154
 155       /* Invoke the callback function to create the corefile segment. */
 156       func (addr, size, read, write, exec, obfd);
 157     }
 158   fclose (mapsfile);
 159   return 0;
 160 }
 161
 162 /* Function: linux_do_thread_registers
 163  *
 164  * Records the thread's register state for the corefile note section.
 165  */
 166
 167 static char *
 168 linux_do_thread_registers (bfd *obfd, ptid_t ptid,
 169                            char *note_data, int *note_size)
 170 {
 171   gdb_gregset_t gregs;
 172   gdb_fpregset_t fpregs;
 173 #ifdef FILL_FPXREGSET
 174   gdb_fpxregset_t fpxregs;
 175 #endif
 176   unsigned long lwp = ptid_get_lwp (ptid);
 177
 178   fill_gregset (&gregs, -1);
 179   note_data = (char *) elfcore_write_prstatus (obfd,
 180                                                note_data,
 181                                                note_size,
 182                                                lwp,
 183                                                stop_signal, &gregs);
 184
 185   fill_fpregset (&fpregs, -1);
 186   note_data = (char *) elfcore_write_prfpreg (obfd,
 187                                               note_data,
 188                                               note_size,
 189                                               &fpregs, sizeof (fpregs));
 190 #ifdef FILL_FPXREGSET
 191   fill_fpxregset (&fpxregs, -1);
 192   note_data = (char *) elfcore_write_prxfpreg (obfd,
 193                                                note_data,
 194                                                note_size,
 195                                                &fpxregs, sizeof (fpxregs));
 196 #endif
 197   return note_data;
 198 }
 199
 200 struct linux_corefile_thread_data
 201 {
 202   bfd *obfd;
 203   char *note_data;
 204   int *note_size;
 205   int num_notes;
 206 };
 207
 208 /* Function: linux_corefile_thread_callback
 209  *
 210  * Called by gdbthread.c once per thread.
 211  * Records the thread's register state for the corefile note section.
 212  */
 213
 214 static int
 215 linux_corefile_thread_callback (struct lwp_info *ti, void *data)
 216 {
 217   struct linux_corefile_thread_data *args = data;
 218   ptid_t saved_ptid = inferior_ptid;
 219
 220   inferior_ptid = ti->ptid;
 221   registers_changed ();
 222   target_fetch_registers (-1);  /* FIXME should not be necessary;
 223                                    fill_gregset should do it automatically. */
 224   args->note_data = linux_do_thread_registers (args->obfd,
 225                                                ti->ptid,
 226                                                args->note_data,
 227                                                args->note_size);
 228   args->num_notes++;
 229   inferior_ptid = saved_ptid;
 230   registers_changed ();
 231   target_fetch_registers (-1);  /* FIXME should not be necessary;
 232                                    fill_gregset should do it automatically. */
 233   return 0;
 234 }
 235
 236 /* Function: linux_make_note_section
 237  *
 238  * Fills the "to_make_corefile_note" target vector.
 239  * Builds the note section for a corefile, and returns it
 240  * in a malloc buffer.
 241  */
 242
 243 static char *
 244 linux_make_note_section (bfd *obfd, int *note_size)
 245 {
 246   struct linux_corefile_thread_data thread_args;
 247   struct cleanup *old_chain;
 248   char fname[16] = { '\0' };
 249   char psargs[80] = { '\0' };
 250   char *note_data = NULL;
 251   ptid_t current_ptid = inferior_ptid;
 252
 253   if (get_exec_file (0))
 254     {
 255       strncpy (fname, strrchr (get_exec_file (0), '/') + 1, sizeof (fname));
 256       strncpy (psargs, get_exec_file (0), sizeof (psargs));
 257       if (get_inferior_args ())
 258         {
 259           strncat (psargs, " ", sizeof (psargs) - strlen (psargs));
 260           strncat (psargs, get_inferior_args (),
 261                    sizeof (psargs) - strlen (psargs));
 262         }
 263       note_data = (char *) elfcore_write_prpsinfo (obfd,
 264                                                    note_data,
 265                                                    note_size, fname, psargs);
 266     }
 267
 268   /* Dump information for threads.  */
 269   thread_args.obfd = obfd;
 270   thread_args.note_data = note_data;
 271   thread_args.note_size = note_size;
 272   thread_args.num_notes = 0;
 273   iterate_over_lwps (linux_corefile_thread_callback, &thread_args);
 274   if (thread_args.num_notes == 0)
 275     {
 276       /* iterate_over_threads didn't come up with any threads;
 277          just use inferior_ptid.  */
 278       note_data = linux_do_thread_registers (obfd, inferior_ptid,
 279                                              note_data, note_size);
 280     }
 281   else
 282     {
 283       note_data = thread_args.note_data;
 284     }
 285
 286   make_cleanup (xfree, note_data);
 287   return note_data;
 288 }
 289
 290 /*
 291  * Function: linux_info_proc_cmd
 292  *
 293  * Implement the "info proc" command.
 294  */
 295
 296 static void
 297 linux_info_proc_cmd (char *args, int from_tty)
 298 {
 299   long long pid = PIDGET (inferior_ptid);
 300   FILE *procfile;
 301   char **argv = NULL;
 302   char buffer[MAXPATHLEN];
 303   char fname1[MAXPATHLEN], fname2[MAXPATHLEN];
 304   int cmdline_f = 1;
 305   int cwd_f = 1;
 306   int exe_f = 1;
 307   int mappings_f = 0;
 308   int environ_f = 0;
 309   int status_f = 0;
 310   int stat_f = 0;
 311   int all = 0;
 312   struct stat dummy;
 313
 314   if (args)
 315     {
 316       /* Break up 'args' into an argv array. */
 317       if ((argv = buildargv (args)) == NULL)
 318         nomem (0);
 319       else
 320         make_cleanup_freeargv (argv);
 321     }
 322   while (argv != NULL && *argv != NULL)
 323     {
 324       if (isdigit (argv[0][0]))
 325         {
 326           pid = strtoul (argv[0], NULL, 10);
 327         }
 328       else if (strncmp (argv[0], "mappings", strlen (argv[0])) == 0)
 329         {
 330           mappings_f = 1;
 331         }
 332       else if (strcmp (argv[0], "status") == 0)
 333         {
 334           status_f = 1;
 335         }
 336       else if (strcmp (argv[0], "stat") == 0)
 337         {
 338           stat_f = 1;
 339         }
 340       else if (strcmp (argv[0], "cmd") == 0)
 341         {
 342           cmdline_f = 1;
 343         }
 344       else if (strncmp (argv[0], "exe", strlen (argv[0])) == 0)
 345         {
 346           exe_f = 1;
 347         }
 348       else if (strcmp (argv[0], "cwd") == 0)
 349         {
 350           cwd_f = 1;
 351         }
 352       else if (strncmp (argv[0], "all", strlen (argv[0])) == 0)
 353         {
 354           all = 1;
 355         }
 356       else
 357         {
 358           /* [...] (future options here) */
 359         }
 360       argv++;
 361     }
 362   if (pid == 0)
 363     error ("No current process: you must name one.");
 364
 365   sprintf (fname1, "/proc/%lld", pid);
 366   if (stat (fname1, &dummy) != 0)
 367     error ("No /proc directory: '%s'", fname1);
 368
 369   printf_filtered ("process %lld\n", pid);
 370   if (cmdline_f || all)
 371     {
 372       sprintf (fname1, "/proc/%lld/cmdline", pid);
 373       if ((procfile = fopen (fname1, "r")) > 0)
 374         {
 375           fgets (buffer, sizeof (buffer), procfile);
 376           printf_filtered ("cmdline = '%s'\n", buffer);
 377           fclose (procfile);
 378         }
 379       else
 380         warning ("unable to open /proc file '%s'", fname1);
 381     }
 382   if (cwd_f || all)
 383     {
 384       sprintf (fname1, "/proc/%lld/cwd", pid);
 385       memset (fname2, 0, sizeof (fname2));
 386       if (readlink (fname1, fname2, sizeof (fname2)) > 0)
 387         printf_filtered ("cwd = '%s'\n", fname2);
 388       else
 389         warning ("unable to read link '%s'", fname1);
 390     }
 391   if (exe_f || all)
 392     {
 393       sprintf (fname1, "/proc/%lld/exe", pid);
 394       memset (fname2, 0, sizeof (fname2));
 395       if (readlink (fname1, fname2, sizeof (fname2)) > 0)
 396         printf_filtered ("exe = '%s'\n", fname2);
 397       else
 398         warning ("unable to read link '%s'", fname1);
 399     }
 400   if (mappings_f || all)
 401     {
 402       sprintf (fname1, "/proc/%lld/maps", pid);
 403       if ((procfile = fopen (fname1, "r")) > 0)
 404         {
 405           long long addr, endaddr, size, offset, inode;
 406           char permissions[8], device[8], filename[MAXPATHLEN];
 407           char *header_fmt_string, *data_fmt_string;
 408
 409           if (TARGET_ADDR_BIT == 32)
 410             {
 411               header_fmt_string = "\t%10s %10s %10s %10s %7s\n";
 412               data_fmt_string = "\t%#10lx %#10lx %#10x %#10x %7s\n";
 413             }
 414           else
 415             {
 416               header_fmt_string = "  %18s %18s %10s %10s %7s\n";
 417               data_fmt_string = "  %#18lx %#18lx %#10x %#10x %7s\n";
 418             }
 419
 420           printf_filtered ("Mapped address spaces:\n\n");
 421           printf_filtered (header_fmt_string,
 422                            "Start Addr",
 423                            "  End Addr",
 424                            "      Size", "    Offset", "objfile");
 425
 426           while (read_mapping (procfile, &addr, &endaddr, &permissions[0],
 427                                &offset, &device[0], &inode, &filename[0]))
 428             {
 429               size = endaddr - addr;
 430               printf_filtered (data_fmt_string, (unsigned long) addr,   /* FIXME: pr_addr */
 431                                (unsigned long) endaddr,
 432                                (int) size,
 433                                (unsigned int) offset,
 434                                filename[0] ? filename : "");
 435
 436             }
 437
 438           fclose (procfile);
 439         }
 440       else
 441         warning ("unable to open /proc file '%s'", fname1);
 442     }
 443   if (status_f || all)
 444     {
 445       sprintf (fname1, "/proc/%lld/status", pid);
 446       if ((procfile = fopen (fname1, "r")) > 0)
 447         {
 448           while (fgets (buffer, sizeof (buffer), procfile) != NULL)
 449             puts_filtered (buffer);
 450           fclose (procfile);
 451         }
 452       else
 453         warning ("unable to open /proc file '%s'", fname1);
 454     }
 455   if (stat_f || all)
 456     {
 457       sprintf (fname1, "/proc/%lld/stat", pid);
 458       if ((procfile = fopen (fname1, "r")) > 0)
 459         {
 460           int itmp;
 461           char ctmp;
 462
 463           if (fscanf (procfile, "%d ", &itmp) > 0)
 464             printf_filtered ("Process: %d\n", itmp);
 465           if (fscanf (procfile, "%s ", &buffer[0]) > 0)
 466             printf_filtered ("Exec file: %s\n", buffer);
 467           if (fscanf (procfile, "%c ", &ctmp) > 0)
 468             printf_filtered ("State: %c\n", ctmp);
 469           if (fscanf (procfile, "%d ", &itmp) > 0)
 470             printf_filtered ("Parent process: %d\n", itmp);
 471           if (fscanf (procfile, "%d ", &itmp) > 0)
 472             printf_filtered ("Process group: %d\n", itmp);
 473           if (fscanf (procfile, "%d ", &itmp) > 0)
 474             printf_filtered ("Session id: %d\n", itmp);
 475           if (fscanf (procfile, "%d ", &itmp) > 0)
 476             printf_filtered ("TTY: %d\n", itmp);
 477           if (fscanf (procfile, "%d ", &itmp) > 0)
 478             printf_filtered ("TTY owner process group: %d\n", itmp);
 479           if (fscanf (procfile, "%u ", &itmp) > 0)
 480             printf_filtered ("Flags: 0x%x\n", itmp);
 481           if (fscanf (procfile, "%u ", &itmp) > 0)
 482             printf_filtered ("Minor faults (no memory page): %u\n",
 483                              (unsigned int) itmp);
 484           if (fscanf (procfile, "%u ", &itmp) > 0)
 485             printf_filtered ("Minor faults, children: %u\n",
 486                              (unsigned int) itmp);
 487           if (fscanf (procfile, "%u ", &itmp) > 0)
 488             printf_filtered ("Major faults (memory page faults): %u\n",
 489                              (unsigned int) itmp);
 490           if (fscanf (procfile, "%u ", &itmp) > 0)
 491             printf_filtered ("Major faults, children: %u\n",
 492                              (unsigned int) itmp);
 493           if (fscanf (procfile, "%d ", &itmp) > 0)
 494             printf_filtered ("utime: %d\n", itmp);
 495           if (fscanf (procfile, "%d ", &itmp) > 0)
 496             printf_filtered ("stime: %d\n", itmp);
 497           if (fscanf (procfile, "%d ", &itmp) > 0)
 498             printf_filtered ("utime, children: %d\n", itmp);
 499           if (fscanf (procfile, "%d ", &itmp) > 0)
 500             printf_filtered ("stime, children: %d\n", itmp);
 501           if (fscanf (procfile, "%d ", &itmp) > 0)
 502             printf_filtered ("jiffies remaining in current time slice: %d\n",
 503                              itmp);
 504           if (fscanf (procfile, "%d ", &itmp) > 0)
 505             printf_filtered ("'nice' value: %d\n", itmp);
 506           if (fscanf (procfile, "%u ", &itmp) > 0)
 507             printf_filtered ("jiffies until next timeout: %u\n",
 508                              (unsigned int) itmp);
 509           if (fscanf (procfile, "%u ", &itmp) > 0)
 510             printf_filtered ("jiffies until next SIGALRM: %u\n",
 511                              (unsigned int) itmp);
 512           if (fscanf (procfile, "%d ", &itmp) > 0)
 513             printf_filtered ("start time (jiffies since system boot): %d\n",
 514                              itmp);
 515           if (fscanf (procfile, "%u ", &itmp) > 0)
 516             printf_filtered ("Virtual memory size: %u\n",
 517                              (unsigned int) itmp);
 518           if (fscanf (procfile, "%u ", &itmp) > 0)
 519             printf_filtered ("Resident set size: %u\n", (unsigned int) itmp);
 520           if (fscanf (procfile, "%u ", &itmp) > 0)
 521             printf_filtered ("rlim: %u\n", (unsigned int) itmp);
 522           if (fscanf (procfile, "%u ", &itmp) > 0)
 523             printf_filtered ("Start of text: 0x%x\n", itmp);
 524           if (fscanf (procfile, "%u ", &itmp) > 0)
 525             printf_filtered ("End of text: 0x%x\n", itmp);
 526           if (fscanf (procfile, "%u ", &itmp) > 0)
 527             printf_filtered ("Start of stack: 0x%x\n", itmp);
 528 #if 0                           /* Don't know how architecture-dependent the rest is...
 529                                    Anyway the signal bitmap info is available from "status".  */
 530           if (fscanf (procfile, "%u ", &itmp) > 0)      /* FIXME arch? */
 531             printf_filtered ("Kernel stack pointer: 0x%x\n", itmp);
 532           if (fscanf (procfile, "%u ", &itmp) > 0)      /* FIXME arch? */
 533             printf_filtered ("Kernel instr pointer: 0x%x\n", itmp);
 534           if (fscanf (procfile, "%d ", &itmp) > 0)
 535             printf_filtered ("Pending signals bitmap: 0x%x\n", itmp);
 536           if (fscanf (procfile, "%d ", &itmp) > 0)
 537             printf_filtered ("Blocked signals bitmap: 0x%x\n", itmp);
 538           if (fscanf (procfile, "%d ", &itmp) > 0)
 539             printf_filtered ("Ignored signals bitmap: 0x%x\n", itmp);
 540           if (fscanf (procfile, "%d ", &itmp) > 0)
 541             printf_filtered ("Catched signals bitmap: 0x%x\n", itmp);
 542           if (fscanf (procfile, "%u ", &itmp) > 0)      /* FIXME arch? */
 543             printf_filtered ("wchan (system call): 0x%x\n", itmp);
 544 #endif
 545           fclose (procfile);
 546         }
 547       else
 548         warning ("unable to open /proc file '%s'", fname1);
 549     }
 550 }
 551
 552 void
 553 _initialize_linux_proc (void)
 554 {
 555   extern void inftarg_set_find_memory_regions ();
 556   extern void inftarg_set_make_corefile_notes ();
 557
 558   inftarg_set_find_memory_regions (linux_find_memory_regions);
 559   inftarg_set_make_corefile_notes (linux_make_note_section);
 560
 561   add_info ("proc", linux_info_proc_cmd,
 562             "Show /proc process information about any running process.\n\
 563 Specify any process id, or use the program being debugged by default.\n\
 564 Specify any of the following keywords for detailed info:\n\
 565   mappings -- list of mapped memory regions.\n\
 566   stat     -- list a bunch of random process info.\n\
 567   status   -- list a different bunch of random process info.\n\
 568   all      -- list all available /proc info.");
 569 }
 570
 571 int
 572 linux_proc_xfer_memory (CORE_ADDR addr, char *myaddr, int len, int write,
 573                         struct mem_attrib *attrib, struct target_ops *target)
 574 {
 575   int fd, ret;
 576   char filename[64];
 577
 578   if (write)
 579     return 0;
 580
 581   /* Don't bother for one word.  */
 582   if (len < 3 * sizeof (long))
 583     return 0;
 584
 585   /* We could keep this file open and cache it - possibly one
 586      per thread.  That requires some juggling, but is even faster.  */
 587   sprintf (filename, "/proc/%d/mem", PIDGET (inferior_ptid));
 588   fd = open (filename, O_RDONLY | O_LARGEFILE);
 589   if (fd == -1)
 590     return 0;
 591
 592   /* If pread64 is available, use it.  It's faster if the kernel
 593      supports it (only one syscall), and it's 64-bit safe even
 594      on 32-bit platforms (for instance, SPARC debugging a SPARC64
 595      application).
 596
 597      We play some autoconf and CFLAGS games to get this declaration
 598      exposed: -D_XOPEN_SOURCE=500 -D_LARGEFILE64_SOURCE.  And then
 599      a -D_BSD_SOURCE to counteract the defaults for _XOPEN_SOURCE.  */
 600 #ifdef HAVE_PREAD64
 601   if (pread64 (fd, myaddr, len, addr) != len)
 602 #else
 603   if (lseek (fd, addr, SEEK_SET) == -1 || read (fd, myaddr, len) != len)
 604 #endif
 605     ret = 0;
 606   else
 607     ret = len;
 608
 609   close (fd);
 610   return ret;
 611 }