gdb/linux-tdep.c

   1 /* Target-dependent code for GNU/Linux, architecture independent.
   2
   3    Copyright (C) 2009-2014 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 3 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, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "gdbtypes.h"
  22 #include "linux-tdep.h"
  23 #include "auxv.h"
  24 #include "target.h"
  25 #include "gdbthread.h"
  26 #include "gdbcore.h"
  27 #include "regcache.h"
  28 #include "regset.h"
  29 #include "elf/common.h"
  30 #include "elf-bfd.h"            /* for elfcore_write_* */
  31 #include "inferior.h"
  32 #include "cli/cli-utils.h"
  33 #include "arch-utils.h"
  34 #include "gdb_obstack.h"
  35
  36 #include <ctype.h>
  37
  38 /* This enum represents the signals' numbers on a generic architecture
  39    running the Linux kernel.  The definition of "generic" comes from
  40    the file <include/uapi/asm-generic/signal.h>, from the Linux kernel
  41    tree, which is the "de facto" implementation of signal numbers to
  42    be used by new architecture ports.
  43
  44    For those architectures which have differences between the generic
  45    standard (e.g., Alpha), we define the different signals (and *only*
  46    those) in the specific target-dependent file (e.g.,
  47    alpha-linux-tdep.c, for Alpha).  Please refer to the architecture's
  48    tdep file for more information.
  49
  50    ARM deserves a special mention here.  On the file
  51    <arch/arm/include/uapi/asm/signal.h>, it defines only one different
  52    (and ARM-only) signal, which is SIGSWI, with the same number as
  53    SIGRTMIN.  This signal is used only for a very specific target,
  54    called ArthurOS (from RISCOS).  Therefore, we do not handle it on
  55    the ARM-tdep file, and we can safely use the generic signal handler
  56    here for ARM targets.
  57
  58    As stated above, this enum is derived from
  59    <include/uapi/asm-generic/signal.h>, from the Linux kernel
  60    tree.  */
  61
  62 enum
  63   {
  64     LINUX_SIGHUP = 1,
  65     LINUX_SIGINT = 2,
  66     LINUX_SIGQUIT = 3,
  67     LINUX_SIGILL = 4,
  68     LINUX_SIGTRAP = 5,
  69     LINUX_SIGABRT = 6,
  70     LINUX_SIGIOT = 6,
  71     LINUX_SIGBUS = 7,
  72     LINUX_SIGFPE = 8,
  73     LINUX_SIGKILL = 9,
  74     LINUX_SIGUSR1 = 10,
  75     LINUX_SIGSEGV = 11,
  76     LINUX_SIGUSR2 = 12,
  77     LINUX_SIGPIPE = 13,
  78     LINUX_SIGALRM = 14,
  79     LINUX_SIGTERM = 15,
  80     LINUX_SIGSTKFLT = 16,
  81     LINUX_SIGCHLD = 17,
  82     LINUX_SIGCONT = 18,
  83     LINUX_SIGSTOP = 19,
  84     LINUX_SIGTSTP = 20,
  85     LINUX_SIGTTIN = 21,
  86     LINUX_SIGTTOU = 22,
  87     LINUX_SIGURG = 23,
  88     LINUX_SIGXCPU = 24,
  89     LINUX_SIGXFSZ = 25,
  90     LINUX_SIGVTALRM = 26,
  91     LINUX_SIGPROF = 27,
  92     LINUX_SIGWINCH = 28,
  93     LINUX_SIGIO = 29,
  94     LINUX_SIGPOLL = LINUX_SIGIO,
  95     LINUX_SIGPWR = 30,
  96     LINUX_SIGSYS = 31,
  97     LINUX_SIGUNUSED = 31,
  98
  99     LINUX_SIGRTMIN = 32,
 100     LINUX_SIGRTMAX = 64,
 101   };
 102
 103 static struct gdbarch_data *linux_gdbarch_data_handle;
 104
 105 struct linux_gdbarch_data
 106   {
 107     struct type *siginfo_type;
 108   };
 109
 110 static void *
 111 init_linux_gdbarch_data (struct gdbarch *gdbarch)
 112 {
 113   return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct linux_gdbarch_data);
 114 }
 115
 116 static struct linux_gdbarch_data *
 117 get_linux_gdbarch_data (struct gdbarch *gdbarch)
 118 {
 119   return gdbarch_data (gdbarch, linux_gdbarch_data_handle);
 120 }
 121
 122 /* This function is suitable for architectures that don't
 123    extend/override the standard siginfo structure.  */
 124
 125 struct type *
 126 linux_get_siginfo_type (struct gdbarch *gdbarch)
 127 {
 128   struct linux_gdbarch_data *linux_gdbarch_data;
 129   struct type *int_type, *uint_type, *long_type, *void_ptr_type;
 130   struct type *uid_type, *pid_type;
 131   struct type *sigval_type, *clock_type;
 132   struct type *siginfo_type, *sifields_type;
 133   struct type *type;
 134
 135   linux_gdbarch_data = get_linux_gdbarch_data (gdbarch);
 136   if (linux_gdbarch_data->siginfo_type != NULL)
 137     return linux_gdbarch_data->siginfo_type;
 138
 139   int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
 140                                 0, "int");
 141   uint_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
 142                                  1, "unsigned int");
 143   long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
 144                                  0, "long");
 145   void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
 146
 147   /* sival_t */
 148   sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
 149   TYPE_NAME (sigval_type) = xstrdup ("sigval_t");
 150   append_composite_type_field (sigval_type, "sival_int", int_type);
 151   append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
 152
 153   /* __pid_t */
 154   pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 155                         TYPE_LENGTH (int_type), "__pid_t");
 156   TYPE_TARGET_TYPE (pid_type) = int_type;
 157   TYPE_TARGET_STUB (pid_type) = 1;
 158
 159   /* __uid_t */
 160   uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 161                         TYPE_LENGTH (uint_type), "__uid_t");
 162   TYPE_TARGET_TYPE (uid_type) = uint_type;
 163   TYPE_TARGET_STUB (uid_type) = 1;
 164
 165   /* __clock_t */
 166   clock_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 167                           TYPE_LENGTH (long_type), "__clock_t");
 168   TYPE_TARGET_TYPE (clock_type) = long_type;
 169   TYPE_TARGET_STUB (clock_type) = 1;
 170
 171   /* _sifields */
 172   sifields_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
 173
 174   {
 175     const int si_max_size = 128;
 176     int si_pad_size;
 177     int size_of_int = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
 178
 179     /* _pad */
 180     if (gdbarch_ptr_bit (gdbarch) == 64)
 181       si_pad_size = (si_max_size / size_of_int) - 4;
 182     else
 183       si_pad_size = (si_max_size / size_of_int) - 3;
 184     append_composite_type_field (sifields_type, "_pad",
 185                                  init_vector_type (int_type, si_pad_size));
 186   }
 187
 188   /* _kill */
 189   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 190   append_composite_type_field (type, "si_pid", pid_type);
 191   append_composite_type_field (type, "si_uid", uid_type);
 192   append_composite_type_field (sifields_type, "_kill", type);
 193
 194   /* _timer */
 195   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 196   append_composite_type_field (type, "si_tid", int_type);
 197   append_composite_type_field (type, "si_overrun", int_type);
 198   append_composite_type_field (type, "si_sigval", sigval_type);
 199   append_composite_type_field (sifields_type, "_timer", type);
 200
 201   /* _rt */
 202   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 203   append_composite_type_field (type, "si_pid", pid_type);
 204   append_composite_type_field (type, "si_uid", uid_type);
 205   append_composite_type_field (type, "si_sigval", sigval_type);
 206   append_composite_type_field (sifields_type, "_rt", type);
 207
 208   /* _sigchld */
 209   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 210   append_composite_type_field (type, "si_pid", pid_type);
 211   append_composite_type_field (type, "si_uid", uid_type);
 212   append_composite_type_field (type, "si_status", int_type);
 213   append_composite_type_field (type, "si_utime", clock_type);
 214   append_composite_type_field (type, "si_stime", clock_type);
 215   append_composite_type_field (sifields_type, "_sigchld", type);
 216
 217   /* _sigfault */
 218   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 219   append_composite_type_field (type, "si_addr", void_ptr_type);
 220   append_composite_type_field (sifields_type, "_sigfault", type);
 221
 222   /* _sigpoll */
 223   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 224   append_composite_type_field (type, "si_band", long_type);
 225   append_composite_type_field (type, "si_fd", int_type);
 226   append_composite_type_field (sifields_type, "_sigpoll", type);
 227
 228   /* struct siginfo */
 229   siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 230   TYPE_NAME (siginfo_type) = xstrdup ("siginfo");
 231   append_composite_type_field (siginfo_type, "si_signo", int_type);
 232   append_composite_type_field (siginfo_type, "si_errno", int_type);
 233   append_composite_type_field (siginfo_type, "si_code", int_type);
 234   append_composite_type_field_aligned (siginfo_type,
 235                                        "_sifields", sifields_type,
 236                                        TYPE_LENGTH (long_type));
 237
 238   linux_gdbarch_data->siginfo_type = siginfo_type;
 239
 240   return siginfo_type;
 241 }
 242
 243 /* Return true if the target is running on uClinux instead of normal
 244    Linux kernel.  */
 245
 246 int
 247 linux_is_uclinux (void)
 248 {
 249   CORE_ADDR dummy;
 250
 251   return (target_auxv_search (&current_target, AT_NULL, &dummy) > 0
 252           && target_auxv_search (&current_target, AT_PAGESZ, &dummy) == 0);
 253 }
 254
 255 static int
 256 linux_has_shared_address_space (struct gdbarch *gdbarch)
 257 {
 258   return linux_is_uclinux ();
 259 }
 260
 261 /* This is how we want PTIDs from core files to be printed.  */
 262
 263 static char *
 264 linux_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
 265 {
 266   static char buf[80];
 267
 268   if (ptid_get_lwp (ptid) != 0)
 269     {
 270       snprintf (buf, sizeof (buf), "LWP %ld", ptid_get_lwp (ptid));
 271       return buf;
 272     }
 273
 274   return normal_pid_to_str (ptid);
 275 }
 276
 277 /* Service function for corefiles and info proc.  */
 278
 279 static void
 280 read_mapping (const char *line,
 281               ULONGEST *addr, ULONGEST *endaddr,
 282               const char **permissions, size_t *permissions_len,
 283               ULONGEST *offset,
 284               const char **device, size_t *device_len,
 285               ULONGEST *inode,
 286               const char **filename)
 287 {
 288   const char *p = line;
 289
 290   *addr = strtoulst (p, &p, 16);
 291   if (*p == '-')
 292     p++;
 293   *endaddr = strtoulst (p, &p, 16);
 294
 295   p = skip_spaces_const (p);
 296   *permissions = p;
 297   while (*p && !isspace (*p))
 298     p++;
 299   *permissions_len = p - *permissions;
 300
 301   *offset = strtoulst (p, &p, 16);
 302
 303   p = skip_spaces_const (p);
 304   *device = p;
 305   while (*p && !isspace (*p))
 306     p++;
 307   *device_len = p - *device;
 308
 309   *inode = strtoulst (p, &p, 10);
 310
 311   p = skip_spaces_const (p);
 312   *filename = p;
 313 }
 314
 315 /* Implement the "info proc" command.  */
 316
 317 static void
 318 linux_info_proc (struct gdbarch *gdbarch, const char *args,
 319                  enum info_proc_what what)
 320 {
 321   /* A long is used for pid instead of an int to avoid a loss of precision
 322      compiler warning from the output of strtoul.  */
 323   long pid;
 324   int cmdline_f = (what == IP_MINIMAL || what == IP_CMDLINE || what == IP_ALL);
 325   int cwd_f = (what == IP_MINIMAL || what == IP_CWD || what == IP_ALL);
 326   int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
 327   int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
 328   int status_f = (what == IP_STATUS || what == IP_ALL);
 329   int stat_f = (what == IP_STAT || what == IP_ALL);
 330   char filename[100];
 331   char *data;
 332   int target_errno;
 333
 334   if (args && isdigit (args[0]))
 335     {
 336       char *tem;
 337
 338       pid = strtoul (args, &tem, 10);
 339       args = tem;
 340     }
 341   else
 342     {
 343       if (!target_has_execution)
 344         error (_("No current process: you must name one."));
 345       if (current_inferior ()->fake_pid_p)
 346         error (_("Can't determine the current process's PID: you must name one."));
 347
 348       pid = current_inferior ()->pid;
 349     }
 350
 351   args = skip_spaces_const (args);
 352   if (args && args[0])
 353     error (_("Too many parameters: %s"), args);
 354
 355   printf_filtered (_("process %ld\n"), pid);
 356   if (cmdline_f)
 357     {
 358       xsnprintf (filename, sizeof filename, "/proc/%ld/cmdline", pid);
 359       data = target_fileio_read_stralloc (filename);
 360       if (data)
 361         {
 362           struct cleanup *cleanup = make_cleanup (xfree, data);
 363           printf_filtered ("cmdline = '%s'\n", data);
 364           do_cleanups (cleanup);
 365         }
 366       else
 367         warning (_("unable to open /proc file '%s'"), filename);
 368     }
 369   if (cwd_f)
 370     {
 371       xsnprintf (filename, sizeof filename, "/proc/%ld/cwd", pid);
 372       data = target_fileio_readlink (filename, &target_errno);
 373       if (data)
 374         {
 375           struct cleanup *cleanup = make_cleanup (xfree, data);
 376           printf_filtered ("cwd = '%s'\n", data);
 377           do_cleanups (cleanup);
 378         }
 379       else
 380         warning (_("unable to read link '%s'"), filename);
 381     }
 382   if (exe_f)
 383     {
 384       xsnprintf (filename, sizeof filename, "/proc/%ld/exe", pid);
 385       data = target_fileio_readlink (filename, &target_errno);
 386       if (data)
 387         {
 388           struct cleanup *cleanup = make_cleanup (xfree, data);
 389           printf_filtered ("exe = '%s'\n", data);
 390           do_cleanups (cleanup);
 391         }
 392       else
 393         warning (_("unable to read link '%s'"), filename);
 394     }
 395   if (mappings_f)
 396     {
 397       xsnprintf (filename, sizeof filename, "/proc/%ld/maps", pid);
 398       data = target_fileio_read_stralloc (filename);
 399       if (data)
 400         {
 401           struct cleanup *cleanup = make_cleanup (xfree, data);
 402           char *line;
 403
 404           printf_filtered (_("Mapped address spaces:\n\n"));
 405           if (gdbarch_addr_bit (gdbarch) == 32)
 406             {
 407               printf_filtered ("\t%10s %10s %10s %10s %s\n",
 408                            "Start Addr",
 409                            "  End Addr",
 410                            "      Size", "    Offset", "objfile");
 411             }
 412           else
 413             {
 414               printf_filtered ("  %18s %18s %10s %10s %s\n",
 415                            "Start Addr",
 416                            "  End Addr",
 417                            "      Size", "    Offset", "objfile");
 418             }
 419
 420           for (line = strtok (data, "\n"); line; line = strtok (NULL, "\n"))
 421             {
 422               ULONGEST addr, endaddr, offset, inode;
 423               const char *permissions, *device, *filename;
 424               size_t permissions_len, device_len;
 425
 426               read_mapping (line, &addr, &endaddr,
 427                             &permissions, &permissions_len,
 428                             &offset, &device, &device_len,
 429                             &inode, &filename);
 430
 431               if (gdbarch_addr_bit (gdbarch) == 32)
 432                 {
 433                   printf_filtered ("\t%10s %10s %10s %10s %s\n",
 434                                    paddress (gdbarch, addr),
 435                                    paddress (gdbarch, endaddr),
 436                                    hex_string (endaddr - addr),
 437                                    hex_string (offset),
 438                                    *filename? filename : "");
 439                 }
 440               else
 441                 {
 442                   printf_filtered ("  %18s %18s %10s %10s %s\n",
 443                                    paddress (gdbarch, addr),
 444                                    paddress (gdbarch, endaddr),
 445                                    hex_string (endaddr - addr),
 446                                    hex_string (offset),
 447                                    *filename? filename : "");
 448                 }
 449             }
 450
 451           do_cleanups (cleanup);
 452         }
 453       else
 454         warning (_("unable to open /proc file '%s'"), filename);
 455     }
 456   if (status_f)
 457     {
 458       xsnprintf (filename, sizeof filename, "/proc/%ld/status", pid);
 459       data = target_fileio_read_stralloc (filename);
 460       if (data)
 461         {
 462           struct cleanup *cleanup = make_cleanup (xfree, data);
 463           puts_filtered (data);
 464           do_cleanups (cleanup);
 465         }
 466       else
 467         warning (_("unable to open /proc file '%s'"), filename);
 468     }
 469   if (stat_f)
 470     {
 471       xsnprintf (filename, sizeof filename, "/proc/%ld/stat", pid);
 472       data = target_fileio_read_stralloc (filename);
 473       if (data)
 474         {
 475           struct cleanup *cleanup = make_cleanup (xfree, data);
 476           const char *p = data;
 477
 478           printf_filtered (_("Process: %s\n"),
 479                            pulongest (strtoulst (p, &p, 10)));
 480
 481           p = skip_spaces_const (p);
 482           if (*p == '(')
 483             {
 484               /* ps command also relies on no trailing fields
 485                  ever contain ')'.  */
 486               const char *ep = strrchr (p, ')');
 487               if (ep != NULL)
 488                 {
 489                   printf_filtered ("Exec file: %.*s\n",
 490                                    (int) (ep - p - 1), p + 1);
 491                   p = ep + 1;
 492                 }
 493             }
 494
 495           p = skip_spaces_const (p);
 496           if (*p)
 497             printf_filtered (_("State: %c\n"), *p++);
 498
 499           if (*p)
 500             printf_filtered (_("Parent process: %s\n"),
 501                              pulongest (strtoulst (p, &p, 10)));
 502           if (*p)
 503             printf_filtered (_("Process group: %s\n"),
 504                              pulongest (strtoulst (p, &p, 10)));
 505           if (*p)
 506             printf_filtered (_("Session id: %s\n"),
 507                              pulongest (strtoulst (p, &p, 10)));
 508           if (*p)
 509             printf_filtered (_("TTY: %s\n"),
 510                              pulongest (strtoulst (p, &p, 10)));
 511           if (*p)
 512             printf_filtered (_("TTY owner process group: %s\n"),
 513                              pulongest (strtoulst (p, &p, 10)));
 514
 515           if (*p)
 516             printf_filtered (_("Flags: %s\n"),
 517                              hex_string (strtoulst (p, &p, 10)));
 518           if (*p)
 519             printf_filtered (_("Minor faults (no memory page): %s\n"),
 520                              pulongest (strtoulst (p, &p, 10)));
 521           if (*p)
 522             printf_filtered (_("Minor faults, children: %s\n"),
 523                              pulongest (strtoulst (p, &p, 10)));
 524           if (*p)
 525             printf_filtered (_("Major faults (memory page faults): %s\n"),
 526                              pulongest (strtoulst (p, &p, 10)));
 527           if (*p)
 528             printf_filtered (_("Major faults, children: %s\n"),
 529                              pulongest (strtoulst (p, &p, 10)));
 530           if (*p)
 531             printf_filtered (_("utime: %s\n"),
 532                              pulongest (strtoulst (p, &p, 10)));
 533           if (*p)
 534             printf_filtered (_("stime: %s\n"),
 535                              pulongest (strtoulst (p, &p, 10)));
 536           if (*p)
 537             printf_filtered (_("utime, children: %s\n"),
 538                              pulongest (strtoulst (p, &p, 10)));
 539           if (*p)
 540             printf_filtered (_("stime, children: %s\n"),
 541                              pulongest (strtoulst (p, &p, 10)));
 542           if (*p)
 543             printf_filtered (_("jiffies remaining in current "
 544                                "time slice: %s\n"),
 545                              pulongest (strtoulst (p, &p, 10)));
 546           if (*p)
 547             printf_filtered (_("'nice' value: %s\n"),
 548                              pulongest (strtoulst (p, &p, 10)));
 549           if (*p)
 550             printf_filtered (_("jiffies until next timeout: %s\n"),
 551                              pulongest (strtoulst (p, &p, 10)));
 552           if (*p)
 553             printf_filtered (_("jiffies until next SIGALRM: %s\n"),
 554                              pulongest (strtoulst (p, &p, 10)));
 555           if (*p)
 556             printf_filtered (_("start time (jiffies since "
 557                                "system boot): %s\n"),
 558                              pulongest (strtoulst (p, &p, 10)));
 559           if (*p)
 560             printf_filtered (_("Virtual memory size: %s\n"),
 561                              pulongest (strtoulst (p, &p, 10)));
 562           if (*p)
 563             printf_filtered (_("Resident set size: %s\n"),
 564                              pulongest (strtoulst (p, &p, 10)));
 565           if (*p)
 566             printf_filtered (_("rlim: %s\n"),
 567                              pulongest (strtoulst (p, &p, 10)));
 568           if (*p)
 569             printf_filtered (_("Start of text: %s\n"),
 570                              hex_string (strtoulst (p, &p, 10)));
 571           if (*p)
 572             printf_filtered (_("End of text: %s\n"),
 573                              hex_string (strtoulst (p, &p, 10)));
 574           if (*p)
 575             printf_filtered (_("Start of stack: %s\n"),
 576                              hex_string (strtoulst (p, &p, 10)));
 577 #if 0   /* Don't know how architecture-dependent the rest is...
 578            Anyway the signal bitmap info is available from "status".  */
 579           if (*p)
 580             printf_filtered (_("Kernel stack pointer: %s\n"),
 581                              hex_string (strtoulst (p, &p, 10)));
 582           if (*p)
 583             printf_filtered (_("Kernel instr pointer: %s\n"),
 584                              hex_string (strtoulst (p, &p, 10)));
 585           if (*p)
 586             printf_filtered (_("Pending signals bitmap: %s\n"),
 587                              hex_string (strtoulst (p, &p, 10)));
 588           if (*p)
 589             printf_filtered (_("Blocked signals bitmap: %s\n"),
 590                              hex_string (strtoulst (p, &p, 10)));
 591           if (*p)
 592             printf_filtered (_("Ignored signals bitmap: %s\n"),
 593                              hex_string (strtoulst (p, &p, 10)));
 594           if (*p)
 595             printf_filtered (_("Catched signals bitmap: %s\n"),
 596                              hex_string (strtoulst (p, &p, 10)));
 597           if (*p)
 598             printf_filtered (_("wchan (system call): %s\n"),
 599                              hex_string (strtoulst (p, &p, 10)));
 600 #endif
 601           do_cleanups (cleanup);
 602         }
 603       else
 604         warning (_("unable to open /proc file '%s'"), filename);
 605     }
 606 }
 607
 608 /* Implement "info proc mappings" for a corefile.  */
 609
 610 static void
 611 linux_core_info_proc_mappings (struct gdbarch *gdbarch, const char *args)
 612 {
 613   asection *section;
 614   ULONGEST count, page_size;
 615   unsigned char *descdata, *filenames, *descend, *contents;
 616   size_t note_size;
 617   unsigned int addr_size_bits, addr_size;
 618   struct cleanup *cleanup;
 619   struct gdbarch *core_gdbarch = gdbarch_from_bfd (core_bfd);
 620   /* We assume this for reading 64-bit core files.  */
 621   gdb_static_assert (sizeof (ULONGEST) >= 8);
 622
 623   section = bfd_get_section_by_name (core_bfd, ".note.linuxcore.file");
 624   if (section == NULL)
 625     {
 626       warning (_("unable to find mappings in core file"));
 627       return;
 628     }
 629
 630   addr_size_bits = gdbarch_addr_bit (core_gdbarch);
 631   addr_size = addr_size_bits / 8;
 632   note_size = bfd_get_section_size (section);
 633
 634   if (note_size < 2 * addr_size)
 635     error (_("malformed core note - too short for header"));
 636
 637   contents = xmalloc (note_size);
 638   cleanup = make_cleanup (xfree, contents);
 639   if (!bfd_get_section_contents (core_bfd, section, contents, 0, note_size))
 640     error (_("could not get core note contents"));
 641
 642   descdata = contents;
 643   descend = descdata + note_size;
 644
 645   if (descdata[note_size - 1] != '\0')
 646     error (_("malformed note - does not end with \\0"));
 647
 648   count = bfd_get (addr_size_bits, core_bfd, descdata);
 649   descdata += addr_size;
 650
 651   page_size = bfd_get (addr_size_bits, core_bfd, descdata);
 652   descdata += addr_size;
 653
 654   if (note_size < 2 * addr_size + count * 3 * addr_size)
 655     error (_("malformed note - too short for supplied file count"));
 656
 657   printf_filtered (_("Mapped address spaces:\n\n"));
 658   if (gdbarch_addr_bit (gdbarch) == 32)
 659     {
 660       printf_filtered ("\t%10s %10s %10s %10s %s\n",
 661                        "Start Addr",
 662                        "  End Addr",
 663                        "      Size", "    Offset", "objfile");
 664     }
 665   else
 666     {
 667       printf_filtered ("  %18s %18s %10s %10s %s\n",
 668                        "Start Addr",
 669                        "  End Addr",
 670                        "      Size", "    Offset", "objfile");
 671     }
 672
 673   filenames = descdata + count * 3 * addr_size;
 674   while (--count > 0)
 675     {
 676       ULONGEST start, end, file_ofs;
 677
 678       if (filenames == descend)
 679         error (_("malformed note - filenames end too early"));
 680
 681       start = bfd_get (addr_size_bits, core_bfd, descdata);
 682       descdata += addr_size;
 683       end = bfd_get (addr_size_bits, core_bfd, descdata);
 684       descdata += addr_size;
 685       file_ofs = bfd_get (addr_size_bits, core_bfd, descdata);
 686       descdata += addr_size;
 687
 688       file_ofs *= page_size;
 689
 690       if (gdbarch_addr_bit (gdbarch) == 32)
 691         printf_filtered ("\t%10s %10s %10s %10s %s\n",
 692                          paddress (gdbarch, start),
 693                          paddress (gdbarch, end),
 694                          hex_string (end - start),
 695                          hex_string (file_ofs),
 696                          filenames);
 697       else
 698         printf_filtered ("  %18s %18s %10s %10s %s\n",
 699                          paddress (gdbarch, start),
 700                          paddress (gdbarch, end),
 701                          hex_string (end - start),
 702                          hex_string (file_ofs),
 703                          filenames);
 704
 705       filenames += 1 + strlen ((char *) filenames);
 706     }
 707
 708   do_cleanups (cleanup);
 709 }
 710
 711 /* Implement "info proc" for a corefile.  */
 712
 713 static void
 714 linux_core_info_proc (struct gdbarch *gdbarch, const char *args,
 715                       enum info_proc_what what)
 716 {
 717   int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
 718   int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
 719
 720   if (exe_f)
 721     {
 722       const char *exe;
 723
 724       exe = bfd_core_file_failing_command (core_bfd);
 725       if (exe != NULL)
 726         printf_filtered ("exe = '%s'\n", exe);
 727       else
 728         warning (_("unable to find command name in core file"));
 729     }
 730
 731   if (mappings_f)
 732     linux_core_info_proc_mappings (gdbarch, args);
 733
 734   if (!exe_f && !mappings_f)
 735     error (_("unable to handle request"));
 736 }
 737
 738 typedef int linux_find_memory_region_ftype (ULONGEST vaddr, ULONGEST size,
 739                                             ULONGEST offset, ULONGEST inode,
 740                                             int read, int write,
 741                                             int exec, int modified,
 742                                             const char *filename,
 743                                             void *data);
 744
 745 /* List memory regions in the inferior for a corefile.  */
 746
 747 static int
 748 linux_find_memory_regions_full (struct gdbarch *gdbarch,
 749                                 linux_find_memory_region_ftype *func,
 750                                 void *obfd)
 751 {
 752   char mapsfilename[100];
 753   char *data;
 754
 755   /* We need to know the real target PID to access /proc.  */
 756   if (current_inferior ()->fake_pid_p)
 757     return 1;
 758
 759   xsnprintf (mapsfilename, sizeof mapsfilename,
 760              "/proc/%d/smaps", current_inferior ()->pid);
 761   data = target_fileio_read_stralloc (mapsfilename);
 762   if (data == NULL)
 763     {
 764       /* Older Linux kernels did not support /proc/PID/smaps.  */
 765       xsnprintf (mapsfilename, sizeof mapsfilename,
 766                  "/proc/%d/maps", current_inferior ()->pid);
 767       data = target_fileio_read_stralloc (mapsfilename);
 768     }
 769   if (data)
 770     {
 771       struct cleanup *cleanup = make_cleanup (xfree, data);
 772       char *line;
 773
 774       line = strtok (data, "\n");
 775       while (line)
 776         {
 777           ULONGEST addr, endaddr, offset, inode;
 778           const char *permissions, *device, *filename;
 779           size_t permissions_len, device_len;
 780           int read, write, exec;
 781           int modified = 0, has_anonymous = 0;
 782
 783           read_mapping (line, &addr, &endaddr, &permissions, &permissions_len,
 784                         &offset, &device, &device_len, &inode, &filename);
 785
 786           /* Decode permissions.  */
 787           read = (memchr (permissions, 'r', permissions_len) != 0);
 788           write = (memchr (permissions, 'w', permissions_len) != 0);
 789           exec = (memchr (permissions, 'x', permissions_len) != 0);
 790
 791           /* Try to detect if region was modified by parsing smaps counters.  */
 792           for (line = strtok (NULL, "\n");
 793                line && line[0] >= 'A' && line[0] <= 'Z';
 794                line = strtok (NULL, "\n"))
 795             {
 796               char keyword[64 + 1];
 797
 798               if (sscanf (line, "%64s", keyword) != 1)
 799                 {
 800                   warning (_("Error parsing {s,}maps file '%s'"), mapsfilename);
 801                   break;
 802                 }
 803               if (strcmp (keyword, "Anonymous:") == 0)
 804                 has_anonymous = 1;
 805               if (strcmp (keyword, "Shared_Dirty:") == 0
 806                   || strcmp (keyword, "Private_Dirty:") == 0
 807                   || strcmp (keyword, "Swap:") == 0
 808                   || strcmp (keyword, "Anonymous:") == 0)
 809                 {
 810                   unsigned long number;
 811
 812                   if (sscanf (line, "%*s%lu", &number) != 1)
 813                     {
 814                       warning (_("Error parsing {s,}maps file '%s' number"),
 815                                mapsfilename);
 816                       break;
 817                     }
 818                   if (number != 0)
 819                     modified = 1;
 820                 }
 821             }
 822
 823           /* Older Linux kernels did not support the "Anonymous:" counter.
 824              If it is missing, we can't be sure - dump all the pages.  */
 825           if (!has_anonymous)
 826             modified = 1;
 827
 828           /* Invoke the callback function to create the corefile segment.  */
 829           func (addr, endaddr - addr, offset, inode,
 830                 read, write, exec, modified, filename, obfd);
 831         }
 832
 833       do_cleanups (cleanup);
 834       return 0;
 835     }
 836
 837   return 1;
 838 }
 839
 840 /* A structure for passing information through
 841    linux_find_memory_regions_full.  */
 842
 843 struct linux_find_memory_regions_data
 844 {
 845   /* The original callback.  */
 846
 847   find_memory_region_ftype func;
 848
 849   /* The original datum.  */
 850
 851   void *obfd;
 852 };
 853
 854 /* A callback for linux_find_memory_regions that converts between the
 855    "full"-style callback and find_memory_region_ftype.  */
 856
 857 static int
 858 linux_find_memory_regions_thunk (ULONGEST vaddr, ULONGEST size,
 859                                  ULONGEST offset, ULONGEST inode,
 860                                  int read, int write, int exec, int modified,
 861                                  const char *filename, void *arg)
 862 {
 863   struct linux_find_memory_regions_data *data = arg;
 864
 865   return data->func (vaddr, size, read, write, exec, modified, data->obfd);
 866 }
 867
 868 /* A variant of linux_find_memory_regions_full that is suitable as the
 869    gdbarch find_memory_regions method.  */
 870
 871 static int
 872 linux_find_memory_regions (struct gdbarch *gdbarch,
 873                            find_memory_region_ftype func, void *obfd)
 874 {
 875   struct linux_find_memory_regions_data data;
 876
 877   data.func = func;
 878   data.obfd = obfd;
 879
 880   return linux_find_memory_regions_full (gdbarch,
 881                                          linux_find_memory_regions_thunk,
 882                                          &data);
 883 }
 884
 885 /* Determine which signal stopped execution.  */
 886
 887 static int
 888 find_signalled_thread (struct thread_info *info, void *data)
 889 {
 890   if (info->suspend.stop_signal != GDB_SIGNAL_0
 891       && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
 892     return 1;
 893
 894   return 0;
 895 }
 896
 897 static enum gdb_signal
 898 find_stop_signal (void)
 899 {
 900   struct thread_info *info =
 901     iterate_over_threads (find_signalled_thread, NULL);
 902
 903   if (info)
 904     return info->suspend.stop_signal;
 905   else
 906     return GDB_SIGNAL_0;
 907 }
 908
 909 /* Generate corefile notes for SPU contexts.  */
 910
 911 static char *
 912 linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
 913 {
 914   static const char *spu_files[] =
 915     {
 916       "object-id",
 917       "mem",
 918       "regs",
 919       "fpcr",
 920       "lslr",
 921       "decr",
 922       "decr_status",
 923       "signal1",
 924       "signal1_type",
 925       "signal2",
 926       "signal2_type",
 927       "event_mask",
 928       "event_status",
 929       "mbox_info",
 930       "ibox_info",
 931       "wbox_info",
 932       "dma_info",
 933       "proxydma_info",
 934    };
 935
 936   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 937   gdb_byte *spu_ids;
 938   LONGEST i, j, size;
 939
 940   /* Determine list of SPU ids.  */
 941   size = target_read_alloc (&current_target, TARGET_OBJECT_SPU,
 942                             NULL, &spu_ids);
 943
 944   /* Generate corefile notes for each SPU file.  */
 945   for (i = 0; i < size; i += 4)
 946     {
 947       int fd = extract_unsigned_integer (spu_ids + i, 4, byte_order);
 948
 949       for (j = 0; j < sizeof (spu_files) / sizeof (spu_files[0]); j++)
 950         {
 951           char annex[32], note_name[32];
 952           gdb_byte *spu_data;
 953           LONGEST spu_len;
 954
 955           xsnprintf (annex, sizeof annex, "%d/%s", fd, spu_files[j]);
 956           spu_len = target_read_alloc (&current_target, TARGET_OBJECT_SPU,
 957                                        annex, &spu_data);
 958           if (spu_len > 0)
 959             {
 960               xsnprintf (note_name, sizeof note_name, "SPU/%s", annex);
 961               note_data = elfcore_write_note (obfd, note_data, note_size,
 962                                               note_name, NT_SPU,
 963                                               spu_data, spu_len);
 964               xfree (spu_data);
 965
 966               if (!note_data)
 967                 {
 968                   xfree (spu_ids);
 969                   return NULL;
 970                 }
 971             }
 972         }
 973     }
 974
 975   if (size > 0)
 976     xfree (spu_ids);
 977
 978   return note_data;
 979 }
 980
 981 /* This is used to pass information from
 982    linux_make_mappings_corefile_notes through
 983    linux_find_memory_regions_full.  */
 984
 985 struct linux_make_mappings_data
 986 {
 987   /* Number of files mapped.  */
 988   ULONGEST file_count;
 989
 990   /* The obstack for the main part of the data.  */
 991   struct obstack *data_obstack;
 992
 993   /* The filename obstack.  */
 994   struct obstack *filename_obstack;
 995
 996   /* The architecture's "long" type.  */
 997   struct type *long_type;
 998 };
 999
1000 static linux_find_memory_region_ftype linux_make_mappings_callback;
1001
1002 /* A callback for linux_find_memory_regions_full that updates the
1003    mappings data for linux_make_mappings_corefile_notes.  */
1004
1005 static int
1006 linux_make_mappings_callback (ULONGEST vaddr, ULONGEST size,
1007                               ULONGEST offset, ULONGEST inode,
1008                               int read, int write, int exec, int modified,
1009                               const char *filename, void *data)
1010 {
1011   struct linux_make_mappings_data *map_data = data;
1012   gdb_byte buf[sizeof (ULONGEST)];
1013
1014   if (*filename == '\0' || inode == 0)
1015     return 0;
1016
1017   ++map_data->file_count;
1018
1019   pack_long (buf, map_data->long_type, vaddr);
1020   obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1021   pack_long (buf, map_data->long_type, vaddr + size);
1022   obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1023   pack_long (buf, map_data->long_type, offset);
1024   obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1025
1026   obstack_grow_str0 (map_data->filename_obstack, filename);
1027
1028   return 0;
1029 }
1030
1031 /* Write the file mapping data to the core file, if possible.  OBFD is
1032    the output BFD.  NOTE_DATA is the current note data, and NOTE_SIZE
1033    is a pointer to the note size.  Returns the new NOTE_DATA and
1034    updates NOTE_SIZE.  */
1035
1036 static char *
1037 linux_make_mappings_corefile_notes (struct gdbarch *gdbarch, bfd *obfd,
1038                                     char *note_data, int *note_size)
1039 {
1040   struct cleanup *cleanup;
1041   struct obstack data_obstack, filename_obstack;
1042   struct linux_make_mappings_data mapping_data;
1043   struct type *long_type
1044     = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), 0, "long");
1045   gdb_byte buf[sizeof (ULONGEST)];
1046
1047   obstack_init (&data_obstack);
1048   cleanup = make_cleanup_obstack_free (&data_obstack);
1049   obstack_init (&filename_obstack);
1050   make_cleanup_obstack_free (&filename_obstack);
1051
1052   mapping_data.file_count = 0;
1053   mapping_data.data_obstack = &data_obstack;
1054   mapping_data.filename_obstack = &filename_obstack;
1055   mapping_data.long_type = long_type;
1056
1057   /* Reserve space for the count.  */
1058   obstack_blank (&data_obstack, TYPE_LENGTH (long_type));
1059   /* We always write the page size as 1 since we have no good way to
1060      determine the correct value.  */
1061   pack_long (buf, long_type, 1);
1062   obstack_grow (&data_obstack, buf, TYPE_LENGTH (long_type));
1063
1064   linux_find_memory_regions_full (gdbarch, linux_make_mappings_callback,
1065                                   &mapping_data);
1066
1067   if (mapping_data.file_count != 0)
1068     {
1069       /* Write the count to the obstack.  */
1070       pack_long ((gdb_byte *) obstack_base (&data_obstack),
1071                  long_type, mapping_data.file_count);
1072
1073       /* Copy the filenames to the data obstack.  */
1074       obstack_grow (&data_obstack, obstack_base (&filename_obstack),
1075                     obstack_object_size (&filename_obstack));
1076
1077       note_data = elfcore_write_note (obfd, note_data, note_size,
1078                                       "CORE", NT_FILE,
1079                                       obstack_base (&data_obstack),
1080                                       obstack_object_size (&data_obstack));
1081     }
1082
1083   do_cleanups (cleanup);
1084   return note_data;
1085 }
1086
1087 /* Structure for passing information from
1088    linux_collect_thread_registers via an iterator to
1089    linux_collect_regset_section_cb. */
1090
1091 struct linux_collect_regset_section_cb_data
1092 {
1093   struct gdbarch *gdbarch;
1094   const struct regcache *regcache;
1095   bfd *obfd;
1096   char *note_data;
1097   int *note_size;
1098   unsigned long lwp;
1099   enum gdb_signal stop_signal;
1100   int abort_iteration;
1101 };
1102
1103 /* Callback for iterate_over_regset_sections that records a single
1104    regset in the corefile note section.  */
1105
1106 static void
1107 linux_collect_regset_section_cb (const char *sect_name, int size,
1108                                  const struct regset *regset,
1109                                  const char *human_name, void *cb_data)
1110 {
1111   char *buf;
1112   struct linux_collect_regset_section_cb_data *data = cb_data;
1113
1114   if (data->abort_iteration)
1115     return;
1116
1117   gdb_assert (regset && regset->collect_regset);
1118
1119   buf = xmalloc (size);
1120   regset->collect_regset (regset, data->regcache, -1, buf, size);
1121
1122   /* PRSTATUS still needs to be treated specially.  */
1123   if (strcmp (sect_name, ".reg") == 0)
1124     data->note_data = (char *) elfcore_write_prstatus
1125       (data->obfd, data->note_data, data->note_size, data->lwp,
1126        gdb_signal_to_host (data->stop_signal), buf);
1127   else
1128     data->note_data = (char *) elfcore_write_register_note
1129       (data->obfd, data->note_data, data->note_size,
1130        sect_name, buf, size);
1131   xfree (buf);
1132
1133   if (data->note_data == NULL)
1134     data->abort_iteration = 1;
1135 }
1136
1137 /* Records the thread's register state for the corefile note
1138    section.  */
1139
1140 static char *
1141 linux_collect_thread_registers (const struct regcache *regcache,
1142                                 ptid_t ptid, bfd *obfd,
1143                                 char *note_data, int *note_size,
1144                                 enum gdb_signal stop_signal)
1145 {
1146   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1147   struct linux_collect_regset_section_cb_data data;
1148
1149   data.gdbarch = gdbarch;
1150   data.regcache = regcache;
1151   data.obfd = obfd;
1152   data.note_data = note_data;
1153   data.note_size = note_size;
1154   data.stop_signal = stop_signal;
1155   data.abort_iteration = 0;
1156
1157   /* For remote targets the LWP may not be available, so use the TID.  */
1158   data.lwp = ptid_get_lwp (ptid);
1159   if (!data.lwp)
1160     data.lwp = ptid_get_tid (ptid);
1161
1162   gdbarch_iterate_over_regset_sections (gdbarch,
1163                                         linux_collect_regset_section_cb,
1164                                         &data, regcache);
1165   return data.note_data;
1166 }
1167
1168 /* Fetch the siginfo data for the current thread, if it exists.  If
1169    there is no data, or we could not read it, return NULL.  Otherwise,
1170    return a newly malloc'd buffer holding the data and fill in *SIZE
1171    with the size of the data.  The caller is responsible for freeing
1172    the data.  */
1173
1174 static gdb_byte *
1175 linux_get_siginfo_data (struct gdbarch *gdbarch, LONGEST *size)
1176 {
1177   struct type *siginfo_type;
1178   gdb_byte *buf;
1179   LONGEST bytes_read;
1180   struct cleanup *cleanups;
1181
1182   if (!gdbarch_get_siginfo_type_p (gdbarch))
1183     return NULL;
1184
1185   siginfo_type = gdbarch_get_siginfo_type (gdbarch);
1186
1187   buf = xmalloc (TYPE_LENGTH (siginfo_type));
1188   cleanups = make_cleanup (xfree, buf);
1189
1190   bytes_read = target_read (&current_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
1191                             buf, 0, TYPE_LENGTH (siginfo_type));
1192   if (bytes_read == TYPE_LENGTH (siginfo_type))
1193     {
1194       discard_cleanups (cleanups);
1195       *size = bytes_read;
1196     }
1197   else
1198     {
1199       do_cleanups (cleanups);
1200       buf = NULL;
1201     }
1202
1203   return buf;
1204 }
1205
1206 struct linux_corefile_thread_data
1207 {
1208   struct gdbarch *gdbarch;
1209   int pid;
1210   bfd *obfd;
1211   char *note_data;
1212   int *note_size;
1213   enum gdb_signal stop_signal;
1214 };
1215
1216 /* Called by gdbthread.c once per thread.  Records the thread's
1217    register state for the corefile note section.  */
1218
1219 static int
1220 linux_corefile_thread_callback (struct thread_info *info, void *data)
1221 {
1222   struct linux_corefile_thread_data *args = data;
1223
1224   /* It can be current thread
1225      which cannot be removed by update_thread_list.  */
1226   if (info->state == THREAD_EXITED)
1227     return 0;
1228
1229   if (ptid_get_pid (info->ptid) == args->pid)
1230     {
1231       struct cleanup *old_chain;
1232       struct regcache *regcache;
1233       gdb_byte *siginfo_data;
1234       LONGEST siginfo_size = 0;
1235
1236       regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
1237
1238       old_chain = save_inferior_ptid ();
1239       inferior_ptid = info->ptid;
1240       target_fetch_registers (regcache, -1);
1241       siginfo_data = linux_get_siginfo_data (args->gdbarch, &siginfo_size);
1242       do_cleanups (old_chain);
1243
1244       old_chain = make_cleanup (xfree, siginfo_data);
1245
1246       args->note_data = linux_collect_thread_registers
1247         (regcache, info->ptid, args->obfd, args->note_data,
1248          args->note_size, args->stop_signal);
1249
1250       /* Don't return anything if we got no register information above,
1251          such a core file is useless.  */
1252       if (args->note_data != NULL)
1253         if (siginfo_data != NULL)
1254           args->note_data = elfcore_write_note (args->obfd,
1255                                                 args->note_data,
1256                                                 args->note_size,
1257                                                 "CORE", NT_SIGINFO,
1258                                                 siginfo_data, siginfo_size);
1259
1260       do_cleanups (old_chain);
1261     }
1262
1263   return !args->note_data;
1264 }
1265
1266 /* Fill the PRPSINFO structure with information about the process being
1267    debugged.  Returns 1 in case of success, 0 for failures.  Please note that
1268    even if the structure cannot be entirely filled (e.g., GDB was unable to
1269    gather information about the process UID/GID), this function will still
1270    return 1 since some information was already recorded.  It will only return
1271    0 iff nothing can be gathered.  */
1272
1273 static int
1274 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo *p)
1275 {
1276   /* The filename which we will use to obtain some info about the process.
1277      We will basically use this to store the `/proc/PID/FILENAME' file.  */
1278   char filename[100];
1279   /* The full name of the program which generated the corefile.  */
1280   char *fname;
1281   /* The basename of the executable.  */
1282   const char *basename;
1283   /* The arguments of the program.  */
1284   char *psargs;
1285   char *infargs;
1286   /* The contents of `/proc/PID/stat' and `/proc/PID/status' files.  */
1287   char *proc_stat, *proc_status;
1288   /* Temporary buffer.  */
1289   char *tmpstr;
1290   /* The valid states of a process, according to the Linux kernel.  */
1291   const char valid_states[] = "RSDTZW";
1292   /* The program state.  */
1293   const char *prog_state;
1294   /* The state of the process.  */
1295   char pr_sname;
1296   /* The PID of the program which generated the corefile.  */
1297   pid_t pid;
1298   /* Process flags.  */
1299   unsigned int pr_flag;
1300   /* Process nice value.  */
1301   long pr_nice;
1302   /* The number of fields read by `sscanf'.  */
1303   int n_fields = 0;
1304   /* Cleanups.  */
1305   struct cleanup *c;
1306   int i;
1307
1308   gdb_assert (p != NULL);
1309
1310   /* Obtaining PID and filename.  */
1311   pid = ptid_get_pid (inferior_ptid);
1312   xsnprintf (filename, sizeof (filename), "/proc/%d/cmdline", (int) pid);
1313   fname = target_fileio_read_stralloc (filename);
1314
1315   if (fname == NULL || *fname == '\0')
1316     {
1317       /* No program name was read, so we won't be able to retrieve more
1318          information about the process.  */
1319       xfree (fname);
1320       return 0;
1321     }
1322
1323   c = make_cleanup (xfree, fname);
1324   memset (p, 0, sizeof (*p));
1325
1326   /* Defining the PID.  */
1327   p->pr_pid = pid;
1328
1329   /* Copying the program name.  Only the basename matters.  */
1330   basename = lbasename (fname);
1331   strncpy (p->pr_fname, basename, sizeof (p->pr_fname));
1332   p->pr_fname[sizeof (p->pr_fname) - 1] = '\0';
1333
1334   infargs = get_inferior_args ();
1335
1336   psargs = xstrdup (fname);
1337   if (infargs != NULL)
1338     psargs = reconcat (psargs, psargs, " ", infargs, NULL);
1339
1340   make_cleanup (xfree, psargs);
1341
1342   strncpy (p->pr_psargs, psargs, sizeof (p->pr_psargs));
1343   p->pr_psargs[sizeof (p->pr_psargs) - 1] = '\0';
1344
1345   xsnprintf (filename, sizeof (filename), "/proc/%d/stat", (int) pid);
1346   proc_stat = target_fileio_read_stralloc (filename);
1347   make_cleanup (xfree, proc_stat);
1348
1349   if (proc_stat == NULL || *proc_stat == '\0')
1350     {
1351       /* Despite being unable to read more information about the
1352          process, we return 1 here because at least we have its
1353          command line, PID and arguments.  */
1354       do_cleanups (c);
1355       return 1;
1356     }
1357
1358   /* Ok, we have the stats.  It's time to do a little parsing of the
1359      contents of the buffer, so that we end up reading what we want.
1360
1361      The following parsing mechanism is strongly based on the
1362      information generated by the `fs/proc/array.c' file, present in
1363      the Linux kernel tree.  More details about how the information is
1364      displayed can be obtained by seeing the manpage of proc(5),
1365      specifically under the entry of `/proc/[pid]/stat'.  */
1366
1367   /* Getting rid of the PID, since we already have it.  */
1368   while (isdigit (*proc_stat))
1369     ++proc_stat;
1370
1371   proc_stat = skip_spaces (proc_stat);
1372
1373   /* ps command also relies on no trailing fields ever contain ')'.  */
1374   proc_stat = strrchr (proc_stat, ')');
1375   if (proc_stat == NULL)
1376     {
1377       do_cleanups (c);
1378       return 1;
1379     }
1380   proc_stat++;
1381
1382   proc_stat = skip_spaces (proc_stat);
1383
1384   n_fields = sscanf (proc_stat,
1385                      "%c"               /* Process state.  */
1386                      "%d%d%d"           /* Parent PID, group ID, session ID.  */
1387                      "%*d%*d"           /* tty_nr, tpgid (not used).  */
1388                      "%u"               /* Flags.  */
1389                      "%*s%*s%*s%*s"     /* minflt, cminflt, majflt,
1390                                            cmajflt (not used).  */
1391                      "%*s%*s%*s%*s"     /* utime, stime, cutime,
1392                                            cstime (not used).  */
1393                      "%*s"              /* Priority (not used).  */
1394                      "%ld",             /* Nice.  */
1395                      &pr_sname,
1396                      &p->pr_ppid, &p->pr_pgrp, &p->pr_sid,
1397                      &pr_flag,
1398                      &pr_nice);
1399
1400   if (n_fields != 6)
1401     {
1402       /* Again, we couldn't read the complementary information about
1403          the process state.  However, we already have minimal
1404          information, so we just return 1 here.  */
1405       do_cleanups (c);
1406       return 1;
1407     }
1408
1409   /* Filling the structure fields.  */
1410   prog_state = strchr (valid_states, pr_sname);
1411   if (prog_state != NULL)
1412     p->pr_state = prog_state - valid_states;
1413   else
1414     {
1415       /* Zero means "Running".  */
1416       p->pr_state = 0;
1417     }
1418
1419   p->pr_sname = p->pr_state > 5 ? '.' : pr_sname;
1420   p->pr_zomb = p->pr_sname == 'Z';
1421   p->pr_nice = pr_nice;
1422   p->pr_flag = pr_flag;
1423
1424   /* Finally, obtaining the UID and GID.  For that, we read and parse the
1425      contents of the `/proc/PID/status' file.  */
1426   xsnprintf (filename, sizeof (filename), "/proc/%d/status", (int) pid);
1427   proc_status = target_fileio_read_stralloc (filename);
1428   make_cleanup (xfree, proc_status);
1429
1430   if (proc_status == NULL || *proc_status == '\0')
1431     {
1432       /* Returning 1 since we already have a bunch of information.  */
1433       do_cleanups (c);
1434       return 1;
1435     }
1436
1437   /* Extracting the UID.  */
1438   tmpstr = strstr (proc_status, "Uid:");
1439   if (tmpstr != NULL)
1440     {
1441       /* Advancing the pointer to the beginning of the UID.  */
1442       tmpstr += sizeof ("Uid:");
1443       while (*tmpstr != '\0' && !isdigit (*tmpstr))
1444         ++tmpstr;
1445
1446       if (isdigit (*tmpstr))
1447         p->pr_uid = strtol (tmpstr, &tmpstr, 10);
1448     }
1449
1450   /* Extracting the GID.  */
1451   tmpstr = strstr (proc_status, "Gid:");
1452   if (tmpstr != NULL)
1453     {
1454       /* Advancing the pointer to the beginning of the GID.  */
1455       tmpstr += sizeof ("Gid:");
1456       while (*tmpstr != '\0' && !isdigit (*tmpstr))
1457         ++tmpstr;
1458
1459       if (isdigit (*tmpstr))
1460         p->pr_gid = strtol (tmpstr, &tmpstr, 10);
1461     }
1462
1463   do_cleanups (c);
1464
1465   return 1;
1466 }
1467
1468 /* Build the note section for a corefile, and return it in a malloc
1469    buffer.  */
1470
1471 static char *
1472 linux_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
1473 {
1474   struct linux_corefile_thread_data thread_args;
1475   struct elf_internal_linux_prpsinfo prpsinfo;
1476   char *note_data = NULL;
1477   gdb_byte *auxv;
1478   int auxv_len;
1479   volatile struct gdb_exception e;
1480
1481   if (! gdbarch_iterate_over_regset_sections_p (gdbarch))
1482     return NULL;
1483
1484   if (linux_fill_prpsinfo (&prpsinfo))
1485     {
1486       if (gdbarch_elfcore_write_linux_prpsinfo_p (gdbarch))
1487         {
1488           note_data = gdbarch_elfcore_write_linux_prpsinfo (gdbarch, obfd,
1489                                                             note_data, note_size,
1490                                                             &prpsinfo);
1491         }
1492       else
1493         {
1494           if (gdbarch_ptr_bit (gdbarch) == 64)
1495             note_data = elfcore_write_linux_prpsinfo64 (obfd,
1496                                                         note_data, note_size,
1497                                                         &prpsinfo);
1498           else
1499             note_data = elfcore_write_linux_prpsinfo32 (obfd,
1500                                                         note_data, note_size,
1501                                                         &prpsinfo);
1502         }
1503     }
1504
1505   /* Thread register information.  */
1506   TRY_CATCH (e, RETURN_MASK_ERROR)
1507     {
1508       update_thread_list ();
1509     }
1510   if (e.reason < 0)
1511     exception_print (gdb_stderr, e);
1512   thread_args.gdbarch = gdbarch;
1513   thread_args.pid = ptid_get_pid (inferior_ptid);
1514   thread_args.obfd = obfd;
1515   thread_args.note_data = note_data;
1516   thread_args.note_size = note_size;
1517   thread_args.stop_signal = find_stop_signal ();
1518   iterate_over_threads (linux_corefile_thread_callback, &thread_args);
1519   note_data = thread_args.note_data;
1520   if (!note_data)
1521     return NULL;
1522
1523   /* Auxillary vector.  */
1524   auxv_len = target_read_alloc (&current_target, TARGET_OBJECT_AUXV,
1525                                 NULL, &auxv);
1526   if (auxv_len > 0)
1527     {
1528       note_data = elfcore_write_note (obfd, note_data, note_size,
1529                                       "CORE", NT_AUXV, auxv, auxv_len);
1530       xfree (auxv);
1531
1532       if (!note_data)
1533         return NULL;
1534     }
1535
1536   /* SPU information.  */
1537   note_data = linux_spu_make_corefile_notes (obfd, note_data, note_size);
1538   if (!note_data)
1539     return NULL;
1540
1541   /* File mappings.  */
1542   note_data = linux_make_mappings_corefile_notes (gdbarch, obfd,
1543                                                   note_data, note_size);
1544
1545   return note_data;
1546 }
1547
1548 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
1549    gdbarch.h.  This function is not static because it is exported to
1550    other -tdep files.  */
1551
1552 enum gdb_signal
1553 linux_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
1554 {
1555   switch (signal)
1556     {
1557     case 0:
1558       return GDB_SIGNAL_0;
1559
1560     case LINUX_SIGHUP:
1561       return GDB_SIGNAL_HUP;
1562
1563     case LINUX_SIGINT:
1564       return GDB_SIGNAL_INT;
1565
1566     case LINUX_SIGQUIT:
1567       return GDB_SIGNAL_QUIT;
1568
1569     case LINUX_SIGILL:
1570       return GDB_SIGNAL_ILL;
1571
1572     case LINUX_SIGTRAP:
1573       return GDB_SIGNAL_TRAP;
1574
1575     case LINUX_SIGABRT:
1576       return GDB_SIGNAL_ABRT;
1577
1578     case LINUX_SIGBUS:
1579       return GDB_SIGNAL_BUS;
1580
1581     case LINUX_SIGFPE:
1582       return GDB_SIGNAL_FPE;
1583
1584     case LINUX_SIGKILL:
1585       return GDB_SIGNAL_KILL;
1586
1587     case LINUX_SIGUSR1:
1588       return GDB_SIGNAL_USR1;
1589
1590     case LINUX_SIGSEGV:
1591       return GDB_SIGNAL_SEGV;
1592
1593     case LINUX_SIGUSR2:
1594       return GDB_SIGNAL_USR2;
1595
1596     case LINUX_SIGPIPE:
1597       return GDB_SIGNAL_PIPE;
1598
1599     case LINUX_SIGALRM:
1600       return GDB_SIGNAL_ALRM;
1601
1602     case LINUX_SIGTERM:
1603       return GDB_SIGNAL_TERM;
1604
1605     case LINUX_SIGCHLD:
1606       return GDB_SIGNAL_CHLD;
1607
1608     case LINUX_SIGCONT:
1609       return GDB_SIGNAL_CONT;
1610
1611     case LINUX_SIGSTOP:
1612       return GDB_SIGNAL_STOP;
1613
1614     case LINUX_SIGTSTP:
1615       return GDB_SIGNAL_TSTP;
1616
1617     case LINUX_SIGTTIN:
1618       return GDB_SIGNAL_TTIN;
1619
1620     case LINUX_SIGTTOU:
1621       return GDB_SIGNAL_TTOU;
1622
1623     case LINUX_SIGURG:
1624       return GDB_SIGNAL_URG;
1625
1626     case LINUX_SIGXCPU:
1627       return GDB_SIGNAL_XCPU;
1628
1629     case LINUX_SIGXFSZ:
1630       return GDB_SIGNAL_XFSZ;
1631
1632     case LINUX_SIGVTALRM:
1633       return GDB_SIGNAL_VTALRM;
1634
1635     case LINUX_SIGPROF:
1636       return GDB_SIGNAL_PROF;
1637
1638     case LINUX_SIGWINCH:
1639       return GDB_SIGNAL_WINCH;
1640
1641     /* No way to differentiate between SIGIO and SIGPOLL.
1642        Therefore, we just handle the first one.  */
1643     case LINUX_SIGIO:
1644       return GDB_SIGNAL_IO;
1645
1646     case LINUX_SIGPWR:
1647       return GDB_SIGNAL_PWR;
1648
1649     case LINUX_SIGSYS:
1650       return GDB_SIGNAL_SYS;
1651
1652     /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
1653        therefore we have to handle them here.  */
1654     case LINUX_SIGRTMIN:
1655       return GDB_SIGNAL_REALTIME_32;
1656
1657     case LINUX_SIGRTMAX:
1658       return GDB_SIGNAL_REALTIME_64;
1659     }
1660
1661   if (signal >= LINUX_SIGRTMIN + 1 && signal <= LINUX_SIGRTMAX - 1)
1662     {
1663       int offset = signal - LINUX_SIGRTMIN + 1;
1664
1665       return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_33 + offset);
1666     }
1667
1668   return GDB_SIGNAL_UNKNOWN;
1669 }
1670
1671 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
1672    gdbarch.h.  This function is not static because it is exported to
1673    other -tdep files.  */
1674
1675 int
1676 linux_gdb_signal_to_target (struct gdbarch *gdbarch,
1677                             enum gdb_signal signal)
1678 {
1679   switch (signal)
1680     {
1681     case GDB_SIGNAL_0:
1682       return 0;
1683
1684     case GDB_SIGNAL_HUP:
1685       return LINUX_SIGHUP;
1686
1687     case GDB_SIGNAL_INT:
1688       return LINUX_SIGINT;
1689
1690     case GDB_SIGNAL_QUIT:
1691       return LINUX_SIGQUIT;
1692
1693     case GDB_SIGNAL_ILL:
1694       return LINUX_SIGILL;
1695
1696     case GDB_SIGNAL_TRAP:
1697       return LINUX_SIGTRAP;
1698
1699     case GDB_SIGNAL_ABRT:
1700       return LINUX_SIGABRT;
1701
1702     case GDB_SIGNAL_FPE:
1703       return LINUX_SIGFPE;
1704
1705     case GDB_SIGNAL_KILL:
1706       return LINUX_SIGKILL;
1707
1708     case GDB_SIGNAL_BUS:
1709       return LINUX_SIGBUS;
1710
1711     case GDB_SIGNAL_SEGV:
1712       return LINUX_SIGSEGV;
1713
1714     case GDB_SIGNAL_SYS:
1715       return LINUX_SIGSYS;
1716
1717     case GDB_SIGNAL_PIPE:
1718       return LINUX_SIGPIPE;
1719
1720     case GDB_SIGNAL_ALRM:
1721       return LINUX_SIGALRM;
1722
1723     case GDB_SIGNAL_TERM:
1724       return LINUX_SIGTERM;
1725
1726     case GDB_SIGNAL_URG:
1727       return LINUX_SIGURG;
1728
1729     case GDB_SIGNAL_STOP:
1730       return LINUX_SIGSTOP;
1731
1732     case GDB_SIGNAL_TSTP:
1733       return LINUX_SIGTSTP;
1734
1735     case GDB_SIGNAL_CONT:
1736       return LINUX_SIGCONT;
1737
1738     case GDB_SIGNAL_CHLD:
1739       return LINUX_SIGCHLD;
1740
1741     case GDB_SIGNAL_TTIN:
1742       return LINUX_SIGTTIN;
1743
1744     case GDB_SIGNAL_TTOU:
1745       return LINUX_SIGTTOU;
1746
1747     case GDB_SIGNAL_IO:
1748       return LINUX_SIGIO;
1749
1750     case GDB_SIGNAL_XCPU:
1751       return LINUX_SIGXCPU;
1752
1753     case GDB_SIGNAL_XFSZ:
1754       return LINUX_SIGXFSZ;
1755
1756     case GDB_SIGNAL_VTALRM:
1757       return LINUX_SIGVTALRM;
1758
1759     case GDB_SIGNAL_PROF:
1760       return LINUX_SIGPROF;
1761
1762     case GDB_SIGNAL_WINCH:
1763       return LINUX_SIGWINCH;
1764
1765     case GDB_SIGNAL_USR1:
1766       return LINUX_SIGUSR1;
1767
1768     case GDB_SIGNAL_USR2:
1769       return LINUX_SIGUSR2;
1770
1771     case GDB_SIGNAL_PWR:
1772       return LINUX_SIGPWR;
1773
1774     case GDB_SIGNAL_POLL:
1775       return LINUX_SIGPOLL;
1776
1777     /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
1778        therefore we have to handle it here.  */
1779     case GDB_SIGNAL_REALTIME_32:
1780       return LINUX_SIGRTMIN;
1781
1782     /* Same comment applies to _64.  */
1783     case GDB_SIGNAL_REALTIME_64:
1784       return LINUX_SIGRTMAX;
1785     }
1786
1787   /* GDB_SIGNAL_REALTIME_33 to _64 are continuous.  */
1788   if (signal >= GDB_SIGNAL_REALTIME_33
1789       && signal <= GDB_SIGNAL_REALTIME_63)
1790     {
1791       int offset = signal - GDB_SIGNAL_REALTIME_33;
1792
1793       return LINUX_SIGRTMIN + 1 + offset;
1794     }
1795
1796   return -1;
1797 }
1798
1799 /* Rummage through mappings to find a mapping's size.  */
1800
1801 static int
1802 find_mapping_size (CORE_ADDR vaddr, unsigned long size,
1803                    int read, int write, int exec, int modified,
1804                    void *data)
1805 {
1806   struct mem_range *range = data;
1807
1808   if (vaddr == range->start)
1809     {
1810       range->length = size;
1811       return 1;
1812     }
1813   return 0;
1814 }
1815
1816 /* Implementation of the "vsyscall_range" gdbarch hook.  */
1817
1818 static int
1819 linux_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range)
1820 {
1821   if (target_auxv_search (&current_target, AT_SYSINFO_EHDR, &range->start) <= 0)
1822     return 0;
1823
1824   /* This is installed by linux_init_abi below, so should always be
1825      available.  */
1826   gdb_assert (gdbarch_find_memory_regions_p (target_gdbarch ()));
1827
1828   range->length = 0;
1829   gdbarch_find_memory_regions (gdbarch, find_mapping_size, range);
1830   return 1;
1831 }
1832
1833 /* To be called from the various GDB_OSABI_LINUX handlers for the
1834    various GNU/Linux architectures and machine types.  */
1835
1836 void
1837 linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1838 {
1839   set_gdbarch_core_pid_to_str (gdbarch, linux_core_pid_to_str);
1840   set_gdbarch_info_proc (gdbarch, linux_info_proc);
1841   set_gdbarch_core_info_proc (gdbarch, linux_core_info_proc);
1842   set_gdbarch_find_memory_regions (gdbarch, linux_find_memory_regions);
1843   set_gdbarch_make_corefile_notes (gdbarch, linux_make_corefile_notes);
1844   set_gdbarch_has_shared_address_space (gdbarch,
1845                                         linux_has_shared_address_space);
1846   set_gdbarch_gdb_signal_from_target (gdbarch,
1847                                       linux_gdb_signal_from_target);
1848   set_gdbarch_gdb_signal_to_target (gdbarch,
1849                                     linux_gdb_signal_to_target);
1850   set_gdbarch_vsyscall_range (gdbarch, linux_vsyscall_range);
1851 }
1852
1853 /* Provide a prototype to silence -Wmissing-prototypes.  */
1854 extern initialize_file_ftype _initialize_linux_tdep;
1855
1856 void
1857 _initialize_linux_tdep (void)
1858 {
1859   linux_gdbarch_data_handle =
1860     gdbarch_data_register_post_init (init_linux_gdbarch_data);
1861 }