gdb/linux-tdep.c

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