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