gdb/linux-tdep.c

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