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   linux_collect_thread_registers_ftype collect;
1215 };
1216
1217 /* Called by gdbthread.c once per thread.  Records the thread's
1218    register state for the corefile note section.  */
1219
1220 static int
1221 linux_corefile_thread_callback (struct thread_info *info, void *data)
1222 {
1223   struct linux_corefile_thread_data *args = data;
1224
1225   /* It can be current thread
1226      which cannot be removed by update_thread_list.  */
1227   if (info->state == THREAD_EXITED)
1228     return 0;
1229
1230   if (ptid_get_pid (info->ptid) == args->pid)
1231     {
1232       struct cleanup *old_chain;
1233       struct regcache *regcache;
1234       gdb_byte *siginfo_data;
1235       LONGEST siginfo_size = 0;
1236
1237       regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
1238
1239       old_chain = save_inferior_ptid ();
1240       inferior_ptid = info->ptid;
1241       target_fetch_registers (regcache, -1);
1242       siginfo_data = linux_get_siginfo_data (args->gdbarch, &siginfo_size);
1243       do_cleanups (old_chain);
1244
1245       old_chain = make_cleanup (xfree, siginfo_data);
1246
1247       args->note_data = args->collect (regcache, info->ptid, args->obfd,
1248                                        args->note_data, args->note_size,
1249                                        args->stop_signal);
1250
1251       /* Don't return anything if we got no register information above,
1252          such a core file is useless.  */
1253       if (args->note_data != NULL)
1254         if (siginfo_data != NULL)
1255           args->note_data = elfcore_write_note (args->obfd,
1256                                                 args->note_data,
1257                                                 args->note_size,
1258                                                 "CORE", NT_SIGINFO,
1259                                                 siginfo_data, siginfo_size);
1260
1261       do_cleanups (old_chain);
1262     }
1263
1264   return !args->note_data;
1265 }
1266
1267 /* Fill the PRPSINFO structure with information about the process being
1268    debugged.  Returns 1 in case of success, 0 for failures.  Please note that
1269    even if the structure cannot be entirely filled (e.g., GDB was unable to
1270    gather information about the process UID/GID), this function will still
1271    return 1 since some information was already recorded.  It will only return
1272    0 iff nothing can be gathered.  */
1273
1274 static int
1275 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo *p)
1276 {
1277   /* The filename which we will use to obtain some info about the process.
1278      We will basically use this to store the `/proc/PID/FILENAME' file.  */
1279   char filename[100];
1280   /* The full name of the program which generated the corefile.  */
1281   char *fname;
1282   /* The basename of the executable.  */
1283   const char *basename;
1284   /* The arguments of the program.  */
1285   char *psargs;
1286   char *infargs;
1287   /* The contents of `/proc/PID/stat' and `/proc/PID/status' files.  */
1288   char *proc_stat, *proc_status;
1289   /* Temporary buffer.  */
1290   char *tmpstr;
1291   /* The valid states of a process, according to the Linux kernel.  */
1292   const char valid_states[] = "RSDTZW";
1293   /* The program state.  */
1294   const char *prog_state;
1295   /* The state of the process.  */
1296   char pr_sname;
1297   /* The PID of the program which generated the corefile.  */
1298   pid_t pid;
1299   /* Process flags.  */
1300   unsigned int pr_flag;
1301   /* Process nice value.  */
1302   long pr_nice;
1303   /* The number of fields read by `sscanf'.  */
1304   int n_fields = 0;
1305   /* Cleanups.  */
1306   struct cleanup *c;
1307   int i;
1308
1309   gdb_assert (p != NULL);
1310
1311   /* Obtaining PID and filename.  */
1312   pid = ptid_get_pid (inferior_ptid);
1313   xsnprintf (filename, sizeof (filename), "/proc/%d/cmdline", (int) pid);
1314   fname = target_fileio_read_stralloc (filename);
1315
1316   if (fname == NULL || *fname == '\0')
1317     {
1318       /* No program name was read, so we won't be able to retrieve more
1319          information about the process.  */
1320       xfree (fname);
1321       return 0;
1322     }
1323
1324   c = make_cleanup (xfree, fname);
1325   memset (p, 0, sizeof (*p));
1326
1327   /* Defining the PID.  */
1328   p->pr_pid = pid;
1329
1330   /* Copying the program name.  Only the basename matters.  */
1331   basename = lbasename (fname);
1332   strncpy (p->pr_fname, basename, sizeof (p->pr_fname));
1333   p->pr_fname[sizeof (p->pr_fname) - 1] = '\0';
1334
1335   infargs = get_inferior_args ();
1336
1337   psargs = xstrdup (fname);
1338   if (infargs != NULL)
1339     psargs = reconcat (psargs, psargs, " ", infargs, NULL);
1340
1341   make_cleanup (xfree, psargs);
1342
1343   strncpy (p->pr_psargs, psargs, sizeof (p->pr_psargs));
1344   p->pr_psargs[sizeof (p->pr_psargs) - 1] = '\0';
1345
1346   xsnprintf (filename, sizeof (filename), "/proc/%d/stat", (int) pid);
1347   proc_stat = target_fileio_read_stralloc (filename);
1348   make_cleanup (xfree, proc_stat);
1349
1350   if (proc_stat == NULL || *proc_stat == '\0')
1351     {
1352       /* Despite being unable to read more information about the
1353          process, we return 1 here because at least we have its
1354          command line, PID and arguments.  */
1355       do_cleanups (c);
1356       return 1;
1357     }
1358
1359   /* Ok, we have the stats.  It's time to do a little parsing of the
1360      contents of the buffer, so that we end up reading what we want.
1361
1362      The following parsing mechanism is strongly based on the
1363      information generated by the `fs/proc/array.c' file, present in
1364      the Linux kernel tree.  More details about how the information is
1365      displayed can be obtained by seeing the manpage of proc(5),
1366      specifically under the entry of `/proc/[pid]/stat'.  */
1367
1368   /* Getting rid of the PID, since we already have it.  */
1369   while (isdigit (*proc_stat))
1370     ++proc_stat;
1371
1372   proc_stat = skip_spaces (proc_stat);
1373
1374   /* ps command also relies on no trailing fields ever contain ')'.  */
1375   proc_stat = strrchr (proc_stat, ')');
1376   if (proc_stat == NULL)
1377     {
1378       do_cleanups (c);
1379       return 1;
1380     }
1381   proc_stat++;
1382
1383   proc_stat = skip_spaces (proc_stat);
1384
1385   n_fields = sscanf (proc_stat,
1386                      "%c"               /* Process state.  */
1387                      "%d%d%d"           /* Parent PID, group ID, session ID.  */
1388                      "%*d%*d"           /* tty_nr, tpgid (not used).  */
1389                      "%u"               /* Flags.  */
1390                      "%*s%*s%*s%*s"     /* minflt, cminflt, majflt,
1391                                            cmajflt (not used).  */
1392                      "%*s%*s%*s%*s"     /* utime, stime, cutime,
1393                                            cstime (not used).  */
1394                      "%*s"              /* Priority (not used).  */
1395                      "%ld",             /* Nice.  */
1396                      &pr_sname,
1397                      &p->pr_ppid, &p->pr_pgrp, &p->pr_sid,
1398                      &pr_flag,
1399                      &pr_nice);
1400
1401   if (n_fields != 6)
1402     {
1403       /* Again, we couldn't read the complementary information about
1404          the process state.  However, we already have minimal
1405          information, so we just return 1 here.  */
1406       do_cleanups (c);
1407       return 1;
1408     }
1409
1410   /* Filling the structure fields.  */
1411   prog_state = strchr (valid_states, pr_sname);
1412   if (prog_state != NULL)
1413     p->pr_state = prog_state - valid_states;
1414   else
1415     {
1416       /* Zero means "Running".  */
1417       p->pr_state = 0;
1418     }
1419
1420   p->pr_sname = p->pr_state > 5 ? '.' : pr_sname;
1421   p->pr_zomb = p->pr_sname == 'Z';
1422   p->pr_nice = pr_nice;
1423   p->pr_flag = pr_flag;
1424
1425   /* Finally, obtaining the UID and GID.  For that, we read and parse the
1426      contents of the `/proc/PID/status' file.  */
1427   xsnprintf (filename, sizeof (filename), "/proc/%d/status", (int) pid);
1428   proc_status = target_fileio_read_stralloc (filename);
1429   make_cleanup (xfree, proc_status);
1430
1431   if (proc_status == NULL || *proc_status == '\0')
1432     {
1433       /* Returning 1 since we already have a bunch of information.  */
1434       do_cleanups (c);
1435       return 1;
1436     }
1437
1438   /* Extracting the UID.  */
1439   tmpstr = strstr (proc_status, "Uid:");
1440   if (tmpstr != NULL)
1441     {
1442       /* Advancing the pointer to the beginning of the UID.  */
1443       tmpstr += sizeof ("Uid:");
1444       while (*tmpstr != '\0' && !isdigit (*tmpstr))
1445         ++tmpstr;
1446
1447       if (isdigit (*tmpstr))
1448         p->pr_uid = strtol (tmpstr, &tmpstr, 10);
1449     }
1450
1451   /* Extracting the GID.  */
1452   tmpstr = strstr (proc_status, "Gid:");
1453   if (tmpstr != NULL)
1454     {
1455       /* Advancing the pointer to the beginning of the GID.  */
1456       tmpstr += sizeof ("Gid:");
1457       while (*tmpstr != '\0' && !isdigit (*tmpstr))
1458         ++tmpstr;
1459
1460       if (isdigit (*tmpstr))
1461         p->pr_gid = strtol (tmpstr, &tmpstr, 10);
1462     }
1463
1464   do_cleanups (c);
1465
1466   return 1;
1467 }
1468
1469 /* Fills the "to_make_corefile_note" target vector.  Builds the note
1470    section for a corefile, and returns it in a malloc buffer.  */
1471
1472 char *
1473 linux_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size,
1474                            linux_collect_thread_registers_ftype collect)
1475 {
1476   struct linux_corefile_thread_data thread_args;
1477   struct elf_internal_linux_prpsinfo prpsinfo;
1478   char *note_data = NULL;
1479   gdb_byte *auxv;
1480   int auxv_len;
1481   volatile struct gdb_exception e;
1482
1483   if (linux_fill_prpsinfo (&prpsinfo))
1484     {
1485       if (gdbarch_elfcore_write_linux_prpsinfo_p (gdbarch))
1486         {
1487           note_data = gdbarch_elfcore_write_linux_prpsinfo (gdbarch, obfd,
1488                                                             note_data, note_size,
1489                                                             &prpsinfo);
1490         }
1491       else
1492         {
1493           if (gdbarch_ptr_bit (gdbarch) == 64)
1494             note_data = elfcore_write_linux_prpsinfo64 (obfd,
1495                                                         note_data, note_size,
1496                                                         &prpsinfo);
1497           else
1498             note_data = elfcore_write_linux_prpsinfo32 (obfd,
1499                                                         note_data, note_size,
1500                                                         &prpsinfo);
1501         }
1502     }
1503
1504   /* Thread register information.  */
1505   TRY_CATCH (e, RETURN_MASK_ERROR)
1506     {
1507       update_thread_list ();
1508     }
1509   if (e.reason < 0)
1510     exception_print (gdb_stderr, e);
1511   thread_args.gdbarch = gdbarch;
1512   thread_args.pid = ptid_get_pid (inferior_ptid);
1513   thread_args.obfd = obfd;
1514   thread_args.note_data = note_data;
1515   thread_args.note_size = note_size;
1516   thread_args.stop_signal = find_stop_signal ();
1517   thread_args.collect = collect;
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 static char *
1549 linux_make_corefile_notes_1 (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
1550 {
1551   /* FIXME: uweigand/2011-10-06: Once all GNU/Linux architectures have been
1552      converted to gdbarch_core_regset_sections, we no longer need to fall back
1553      to the target method at this point.  */
1554
1555   if (!gdbarch_iterate_over_regset_sections_p (gdbarch))
1556     return target_make_corefile_notes (obfd, note_size);
1557   else
1558     return linux_make_corefile_notes (gdbarch, obfd, note_size,
1559                                       linux_collect_thread_registers);
1560 }
1561
1562 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
1563    gdbarch.h.  This function is not static because it is exported to
1564    other -tdep files.  */
1565
1566 enum gdb_signal
1567 linux_gdb_signal_from_target (struct gdbarch *gdbarch, int signal)
1568 {
1569   switch (signal)
1570     {
1571     case 0:
1572       return GDB_SIGNAL_0;
1573
1574     case LINUX_SIGHUP:
1575       return GDB_SIGNAL_HUP;
1576
1577     case LINUX_SIGINT:
1578       return GDB_SIGNAL_INT;
1579
1580     case LINUX_SIGQUIT:
1581       return GDB_SIGNAL_QUIT;
1582
1583     case LINUX_SIGILL:
1584       return GDB_SIGNAL_ILL;
1585
1586     case LINUX_SIGTRAP:
1587       return GDB_SIGNAL_TRAP;
1588
1589     case LINUX_SIGABRT:
1590       return GDB_SIGNAL_ABRT;
1591
1592     case LINUX_SIGBUS:
1593       return GDB_SIGNAL_BUS;
1594
1595     case LINUX_SIGFPE:
1596       return GDB_SIGNAL_FPE;
1597
1598     case LINUX_SIGKILL:
1599       return GDB_SIGNAL_KILL;
1600
1601     case LINUX_SIGUSR1:
1602       return GDB_SIGNAL_USR1;
1603
1604     case LINUX_SIGSEGV:
1605       return GDB_SIGNAL_SEGV;
1606
1607     case LINUX_SIGUSR2:
1608       return GDB_SIGNAL_USR2;
1609
1610     case LINUX_SIGPIPE:
1611       return GDB_SIGNAL_PIPE;
1612
1613     case LINUX_SIGALRM:
1614       return GDB_SIGNAL_ALRM;
1615
1616     case LINUX_SIGTERM:
1617       return GDB_SIGNAL_TERM;
1618
1619     case LINUX_SIGCHLD:
1620       return GDB_SIGNAL_CHLD;
1621
1622     case LINUX_SIGCONT:
1623       return GDB_SIGNAL_CONT;
1624
1625     case LINUX_SIGSTOP:
1626       return GDB_SIGNAL_STOP;
1627
1628     case LINUX_SIGTSTP:
1629       return GDB_SIGNAL_TSTP;
1630
1631     case LINUX_SIGTTIN:
1632       return GDB_SIGNAL_TTIN;
1633
1634     case LINUX_SIGTTOU:
1635       return GDB_SIGNAL_TTOU;
1636
1637     case LINUX_SIGURG:
1638       return GDB_SIGNAL_URG;
1639
1640     case LINUX_SIGXCPU:
1641       return GDB_SIGNAL_XCPU;
1642
1643     case LINUX_SIGXFSZ:
1644       return GDB_SIGNAL_XFSZ;
1645
1646     case LINUX_SIGVTALRM:
1647       return GDB_SIGNAL_VTALRM;
1648
1649     case LINUX_SIGPROF:
1650       return GDB_SIGNAL_PROF;
1651
1652     case LINUX_SIGWINCH:
1653       return GDB_SIGNAL_WINCH;
1654
1655     /* No way to differentiate between SIGIO and SIGPOLL.
1656        Therefore, we just handle the first one.  */
1657     case LINUX_SIGIO:
1658       return GDB_SIGNAL_IO;
1659
1660     case LINUX_SIGPWR:
1661       return GDB_SIGNAL_PWR;
1662
1663     case LINUX_SIGSYS:
1664       return GDB_SIGNAL_SYS;
1665
1666     /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
1667        therefore we have to handle them here.  */
1668     case LINUX_SIGRTMIN:
1669       return GDB_SIGNAL_REALTIME_32;
1670
1671     case LINUX_SIGRTMAX:
1672       return GDB_SIGNAL_REALTIME_64;
1673     }
1674
1675   if (signal >= LINUX_SIGRTMIN + 1 && signal <= LINUX_SIGRTMAX - 1)
1676     {
1677       int offset = signal - LINUX_SIGRTMIN + 1;
1678
1679       return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_33 + offset);
1680     }
1681
1682   return GDB_SIGNAL_UNKNOWN;
1683 }
1684
1685 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
1686    gdbarch.h.  This function is not static because it is exported to
1687    other -tdep files.  */
1688
1689 int
1690 linux_gdb_signal_to_target (struct gdbarch *gdbarch,
1691                             enum gdb_signal signal)
1692 {
1693   switch (signal)
1694     {
1695     case GDB_SIGNAL_0:
1696       return 0;
1697
1698     case GDB_SIGNAL_HUP:
1699       return LINUX_SIGHUP;
1700
1701     case GDB_SIGNAL_INT:
1702       return LINUX_SIGINT;
1703
1704     case GDB_SIGNAL_QUIT:
1705       return LINUX_SIGQUIT;
1706
1707     case GDB_SIGNAL_ILL:
1708       return LINUX_SIGILL;
1709
1710     case GDB_SIGNAL_TRAP:
1711       return LINUX_SIGTRAP;
1712
1713     case GDB_SIGNAL_ABRT:
1714       return LINUX_SIGABRT;
1715
1716     case GDB_SIGNAL_FPE:
1717       return LINUX_SIGFPE;
1718
1719     case GDB_SIGNAL_KILL:
1720       return LINUX_SIGKILL;
1721
1722     case GDB_SIGNAL_BUS:
1723       return LINUX_SIGBUS;
1724
1725     case GDB_SIGNAL_SEGV:
1726       return LINUX_SIGSEGV;
1727
1728     case GDB_SIGNAL_SYS:
1729       return LINUX_SIGSYS;
1730
1731     case GDB_SIGNAL_PIPE:
1732       return LINUX_SIGPIPE;
1733
1734     case GDB_SIGNAL_ALRM:
1735       return LINUX_SIGALRM;
1736
1737     case GDB_SIGNAL_TERM:
1738       return LINUX_SIGTERM;
1739
1740     case GDB_SIGNAL_URG:
1741       return LINUX_SIGURG;
1742
1743     case GDB_SIGNAL_STOP:
1744       return LINUX_SIGSTOP;
1745
1746     case GDB_SIGNAL_TSTP:
1747       return LINUX_SIGTSTP;
1748
1749     case GDB_SIGNAL_CONT:
1750       return LINUX_SIGCONT;
1751
1752     case GDB_SIGNAL_CHLD:
1753       return LINUX_SIGCHLD;
1754
1755     case GDB_SIGNAL_TTIN:
1756       return LINUX_SIGTTIN;
1757
1758     case GDB_SIGNAL_TTOU:
1759       return LINUX_SIGTTOU;
1760
1761     case GDB_SIGNAL_IO:
1762       return LINUX_SIGIO;
1763
1764     case GDB_SIGNAL_XCPU:
1765       return LINUX_SIGXCPU;
1766
1767     case GDB_SIGNAL_XFSZ:
1768       return LINUX_SIGXFSZ;
1769
1770     case GDB_SIGNAL_VTALRM:
1771       return LINUX_SIGVTALRM;
1772
1773     case GDB_SIGNAL_PROF:
1774       return LINUX_SIGPROF;
1775
1776     case GDB_SIGNAL_WINCH:
1777       return LINUX_SIGWINCH;
1778
1779     case GDB_SIGNAL_USR1:
1780       return LINUX_SIGUSR1;
1781
1782     case GDB_SIGNAL_USR2:
1783       return LINUX_SIGUSR2;
1784
1785     case GDB_SIGNAL_PWR:
1786       return LINUX_SIGPWR;
1787
1788     case GDB_SIGNAL_POLL:
1789       return LINUX_SIGPOLL;
1790
1791     /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
1792        therefore we have to handle it here.  */
1793     case GDB_SIGNAL_REALTIME_32:
1794       return LINUX_SIGRTMIN;
1795
1796     /* Same comment applies to _64.  */
1797     case GDB_SIGNAL_REALTIME_64:
1798       return LINUX_SIGRTMAX;
1799     }
1800
1801   /* GDB_SIGNAL_REALTIME_33 to _64 are continuous.  */
1802   if (signal >= GDB_SIGNAL_REALTIME_33
1803       && signal <= GDB_SIGNAL_REALTIME_63)
1804     {
1805       int offset = signal - GDB_SIGNAL_REALTIME_33;
1806
1807       return LINUX_SIGRTMIN + 1 + offset;
1808     }
1809
1810   return -1;
1811 }
1812
1813 /* To be called from the various GDB_OSABI_LINUX handlers for the
1814    various GNU/Linux architectures and machine types.  */
1815
1816 void
1817 linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1818 {
1819   set_gdbarch_core_pid_to_str (gdbarch, linux_core_pid_to_str);
1820   set_gdbarch_info_proc (gdbarch, linux_info_proc);
1821   set_gdbarch_core_info_proc (gdbarch, linux_core_info_proc);
1822   set_gdbarch_find_memory_regions (gdbarch, linux_find_memory_regions);
1823   set_gdbarch_make_corefile_notes (gdbarch, linux_make_corefile_notes_1);
1824   set_gdbarch_has_shared_address_space (gdbarch,
1825                                         linux_has_shared_address_space);
1826   set_gdbarch_gdb_signal_from_target (gdbarch,
1827                                       linux_gdb_signal_from_target);
1828   set_gdbarch_gdb_signal_to_target (gdbarch,
1829                                     linux_gdb_signal_to_target);
1830 }
1831
1832 /* Provide a prototype to silence -Wmissing-prototypes.  */
1833 extern initialize_file_ftype _initialize_linux_tdep;
1834
1835 void
1836 _initialize_linux_tdep (void)
1837 {
1838   linux_gdbarch_data_handle =
1839     gdbarch_data_register_post_init (init_linux_gdbarch_data);
1840 }