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