gdb/linux-tdep.c

   1 /* Target-dependent code for GNU/Linux, architecture independent.
   2
   3    Copyright (C) 2009-2012 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
  34 #include <ctype.h>
  35
  36 static struct gdbarch_data *linux_gdbarch_data_handle;
  37
  38 struct linux_gdbarch_data
  39   {
  40     struct type *siginfo_type;
  41   };
  42
  43 static void *
  44 init_linux_gdbarch_data (struct gdbarch *gdbarch)
  45 {
  46   return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct linux_gdbarch_data);
  47 }
  48
  49 static struct linux_gdbarch_data *
  50 get_linux_gdbarch_data (struct gdbarch *gdbarch)
  51 {
  52   return gdbarch_data (gdbarch, linux_gdbarch_data_handle);
  53 }
  54
  55 /* This function is suitable for architectures that don't
  56    extend/override the standard siginfo structure.  */
  57
  58 struct type *
  59 linux_get_siginfo_type (struct gdbarch *gdbarch)
  60 {
  61   struct linux_gdbarch_data *linux_gdbarch_data;
  62   struct type *int_type, *uint_type, *long_type, *void_ptr_type;
  63   struct type *uid_type, *pid_type;
  64   struct type *sigval_type, *clock_type;
  65   struct type *siginfo_type, *sifields_type;
  66   struct type *type;
  67
  68   linux_gdbarch_data = get_linux_gdbarch_data (gdbarch);
  69   if (linux_gdbarch_data->siginfo_type != NULL)
  70     return linux_gdbarch_data->siginfo_type;
  71
  72   int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
  73                                 0, "int");
  74   uint_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
  75                                  1, "unsigned int");
  76   long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
  77                                  0, "long");
  78   void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
  79
  80   /* sival_t */
  81   sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
  82   TYPE_NAME (sigval_type) = xstrdup ("sigval_t");
  83   append_composite_type_field (sigval_type, "sival_int", int_type);
  84   append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
  85
  86   /* __pid_t */
  87   pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
  88                         TYPE_LENGTH (int_type), "__pid_t");
  89   TYPE_TARGET_TYPE (pid_type) = int_type;
  90   TYPE_TARGET_STUB (pid_type) = 1;
  91
  92   /* __uid_t */
  93   uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
  94                         TYPE_LENGTH (uint_type), "__uid_t");
  95   TYPE_TARGET_TYPE (uid_type) = uint_type;
  96   TYPE_TARGET_STUB (uid_type) = 1;
  97
  98   /* __clock_t */
  99   clock_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
 100                           TYPE_LENGTH (long_type), "__clock_t");
 101   TYPE_TARGET_TYPE (clock_type) = long_type;
 102   TYPE_TARGET_STUB (clock_type) = 1;
 103
 104   /* _sifields */
 105   sifields_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
 106
 107   {
 108     const int si_max_size = 128;
 109     int si_pad_size;
 110     int size_of_int = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
 111
 112     /* _pad */
 113     if (gdbarch_ptr_bit (gdbarch) == 64)
 114       si_pad_size = (si_max_size / size_of_int) - 4;
 115     else
 116       si_pad_size = (si_max_size / size_of_int) - 3;
 117     append_composite_type_field (sifields_type, "_pad",
 118                                  init_vector_type (int_type, si_pad_size));
 119   }
 120
 121   /* _kill */
 122   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 123   append_composite_type_field (type, "si_pid", pid_type);
 124   append_composite_type_field (type, "si_uid", uid_type);
 125   append_composite_type_field (sifields_type, "_kill", type);
 126
 127   /* _timer */
 128   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 129   append_composite_type_field (type, "si_tid", int_type);
 130   append_composite_type_field (type, "si_overrun", int_type);
 131   append_composite_type_field (type, "si_sigval", sigval_type);
 132   append_composite_type_field (sifields_type, "_timer", type);
 133
 134   /* _rt */
 135   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 136   append_composite_type_field (type, "si_pid", pid_type);
 137   append_composite_type_field (type, "si_uid", uid_type);
 138   append_composite_type_field (type, "si_sigval", sigval_type);
 139   append_composite_type_field (sifields_type, "_rt", type);
 140
 141   /* _sigchld */
 142   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 143   append_composite_type_field (type, "si_pid", pid_type);
 144   append_composite_type_field (type, "si_uid", uid_type);
 145   append_composite_type_field (type, "si_status", int_type);
 146   append_composite_type_field (type, "si_utime", clock_type);
 147   append_composite_type_field (type, "si_stime", clock_type);
 148   append_composite_type_field (sifields_type, "_sigchld", type);
 149
 150   /* _sigfault */
 151   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 152   append_composite_type_field (type, "si_addr", void_ptr_type);
 153   append_composite_type_field (sifields_type, "_sigfault", type);
 154
 155   /* _sigpoll */
 156   type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 157   append_composite_type_field (type, "si_band", long_type);
 158   append_composite_type_field (type, "si_fd", int_type);
 159   append_composite_type_field (sifields_type, "_sigpoll", type);
 160
 161   /* struct siginfo */
 162   siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
 163   TYPE_NAME (siginfo_type) = xstrdup ("siginfo");
 164   append_composite_type_field (siginfo_type, "si_signo", int_type);
 165   append_composite_type_field (siginfo_type, "si_errno", int_type);
 166   append_composite_type_field (siginfo_type, "si_code", int_type);
 167   append_composite_type_field_aligned (siginfo_type,
 168                                        "_sifields", sifields_type,
 169                                        TYPE_LENGTH (long_type));
 170
 171   linux_gdbarch_data->siginfo_type = siginfo_type;
 172
 173   return siginfo_type;
 174 }
 175
 176 static int
 177 linux_has_shared_address_space (struct gdbarch *gdbarch)
 178 {
 179   /* Determine whether we are running on uClinux or normal Linux
 180      kernel.  */
 181   CORE_ADDR dummy;
 182   int target_is_uclinux;
 183
 184   target_is_uclinux
 185     = (target_auxv_search (&current_target, AT_NULL, &dummy) > 0
 186        && target_auxv_search (&current_target, AT_PAGESZ, &dummy) == 0);
 187
 188   return target_is_uclinux;
 189 }
 190
 191 /* This is how we want PTIDs from core files to be printed.  */
 192
 193 static char *
 194 linux_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
 195 {
 196   static char buf[80];
 197
 198   if (ptid_get_lwp (ptid) != 0)
 199     {
 200       snprintf (buf, sizeof (buf), "LWP %ld", ptid_get_lwp (ptid));
 201       return buf;
 202     }
 203
 204   return normal_pid_to_str (ptid);
 205 }
 206
 207 /* Service function for corefiles and info proc.  */
 208
 209 static void
 210 read_mapping (const char *line,
 211               ULONGEST *addr, ULONGEST *endaddr,
 212               const char **permissions, size_t *permissions_len,
 213               ULONGEST *offset,
 214               const char **device, size_t *device_len,
 215               ULONGEST *inode,
 216               const char **filename)
 217 {
 218   const char *p = line;
 219
 220   *addr = strtoulst (p, &p, 16);
 221   if (*p == '-')
 222     p++;
 223   *endaddr = strtoulst (p, &p, 16);
 224
 225   while (*p && isspace (*p))
 226     p++;
 227   *permissions = p;
 228   while (*p && !isspace (*p))
 229     p++;
 230   *permissions_len = p - *permissions;
 231
 232   *offset = strtoulst (p, &p, 16);
 233
 234   while (*p && isspace (*p))
 235     p++;
 236   *device = p;
 237   while (*p && !isspace (*p))
 238     p++;
 239   *device_len = p - *device;
 240
 241   *inode = strtoulst (p, &p, 10);
 242
 243   while (*p && isspace (*p))
 244     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           while (*p && isspace (*p))
 410             p++;
 411           if (*p == '(')
 412             {
 413               const char *ep = strchr (p, ')');
 414               if (ep != NULL)
 415                 {
 416                   printf_filtered ("Exec file: %.*s\n",
 417                                    (int) (ep - p - 1), p + 1);
 418                   p = ep + 1;
 419                 }
 420             }
 421
 422           while (*p && isspace (*p))
 423             p++;
 424           if (*p)
 425             printf_filtered (_("State: %c\n"), *p++);
 426
 427           if (*p)
 428             printf_filtered (_("Parent process: %s\n"),
 429                              pulongest (strtoulst (p, &p, 10)));
 430           if (*p)
 431             printf_filtered (_("Process group: %s\n"),
 432                              pulongest (strtoulst (p, &p, 10)));
 433           if (*p)
 434             printf_filtered (_("Session id: %s\n"),
 435                              pulongest (strtoulst (p, &p, 10)));
 436           if (*p)
 437             printf_filtered (_("TTY: %s\n"),
 438                              pulongest (strtoulst (p, &p, 10)));
 439           if (*p)
 440             printf_filtered (_("TTY owner process group: %s\n"),
 441                              pulongest (strtoulst (p, &p, 10)));
 442
 443           if (*p)
 444             printf_filtered (_("Flags: %s\n"),
 445                              hex_string (strtoulst (p, &p, 10)));
 446           if (*p)
 447             printf_filtered (_("Minor faults (no memory page): %s\n"),
 448                              pulongest (strtoulst (p, &p, 10)));
 449           if (*p)
 450             printf_filtered (_("Minor faults, children: %s\n"),
 451                              pulongest (strtoulst (p, &p, 10)));
 452           if (*p)
 453             printf_filtered (_("Major faults (memory page faults): %s\n"),
 454                              pulongest (strtoulst (p, &p, 10)));
 455           if (*p)
 456             printf_filtered (_("Major faults, children: %s\n"),
 457                              pulongest (strtoulst (p, &p, 10)));
 458           if (*p)
 459             printf_filtered (_("utime: %s\n"),
 460                              pulongest (strtoulst (p, &p, 10)));
 461           if (*p)
 462             printf_filtered (_("stime: %s\n"),
 463                              pulongest (strtoulst (p, &p, 10)));
 464           if (*p)
 465             printf_filtered (_("utime, children: %s\n"),
 466                              pulongest (strtoulst (p, &p, 10)));
 467           if (*p)
 468             printf_filtered (_("stime, children: %s\n"),
 469                              pulongest (strtoulst (p, &p, 10)));
 470           if (*p)
 471             printf_filtered (_("jiffies remaining in current "
 472                                "time slice: %s\n"),
 473                              pulongest (strtoulst (p, &p, 10)));
 474           if (*p)
 475             printf_filtered (_("'nice' value: %s\n"),
 476                              pulongest (strtoulst (p, &p, 10)));
 477           if (*p)
 478             printf_filtered (_("jiffies until next timeout: %s\n"),
 479                              pulongest (strtoulst (p, &p, 10)));
 480           if (*p)
 481             printf_filtered (_("jiffies until next SIGALRM: %s\n"),
 482                              pulongest (strtoulst (p, &p, 10)));
 483           if (*p)
 484             printf_filtered (_("start time (jiffies since "
 485                                "system boot): %s\n"),
 486                              pulongest (strtoulst (p, &p, 10)));
 487           if (*p)
 488             printf_filtered (_("Virtual memory size: %s\n"),
 489                              pulongest (strtoulst (p, &p, 10)));
 490           if (*p)
 491             printf_filtered (_("Resident set size: %s\n"),
 492                              pulongest (strtoulst (p, &p, 10)));
 493           if (*p)
 494             printf_filtered (_("rlim: %s\n"),
 495                              pulongest (strtoulst (p, &p, 10)));
 496           if (*p)
 497             printf_filtered (_("Start of text: %s\n"),
 498                              hex_string (strtoulst (p, &p, 10)));
 499           if (*p)
 500             printf_filtered (_("End of text: %s\n"),
 501                              hex_string (strtoulst (p, &p, 10)));
 502           if (*p)
 503             printf_filtered (_("Start of stack: %s\n"),
 504                              hex_string (strtoulst (p, &p, 10)));
 505 #if 0   /* Don't know how architecture-dependent the rest is...
 506            Anyway the signal bitmap info is available from "status".  */
 507           if (*p)
 508             printf_filtered (_("Kernel stack pointer: %s\n"),
 509                              hex_string (strtoulst (p, &p, 10)));
 510           if (*p)
 511             printf_filtered (_("Kernel instr pointer: %s\n"),
 512                              hex_string (strtoulst (p, &p, 10)));
 513           if (*p)
 514             printf_filtered (_("Pending signals bitmap: %s\n"),
 515                              hex_string (strtoulst (p, &p, 10)));
 516           if (*p)
 517             printf_filtered (_("Blocked signals bitmap: %s\n"),
 518                              hex_string (strtoulst (p, &p, 10)));
 519           if (*p)
 520             printf_filtered (_("Ignored signals bitmap: %s\n"),
 521                              hex_string (strtoulst (p, &p, 10)));
 522           if (*p)
 523             printf_filtered (_("Catched signals bitmap: %s\n"),
 524                              hex_string (strtoulst (p, &p, 10)));
 525           if (*p)
 526             printf_filtered (_("wchan (system call): %s\n"),
 527                              hex_string (strtoulst (p, &p, 10)));
 528 #endif
 529           do_cleanups (cleanup);
 530         }
 531       else
 532         warning (_("unable to open /proc file '%s'"), filename);
 533     }
 534 }
 535
 536 /* List memory regions in the inferior for a corefile.  */
 537
 538 static int
 539 linux_find_memory_regions (struct gdbarch *gdbarch,
 540                            find_memory_region_ftype func, void *obfd)
 541 {
 542   char filename[100];
 543   gdb_byte *data;
 544
 545   /* We need to know the real target PID to access /proc.  */
 546   if (current_inferior ()->fake_pid_p)
 547     return 1;
 548
 549   xsnprintf (filename, sizeof filename,
 550              "/proc/%d/smaps", current_inferior ()->pid);
 551   data = target_fileio_read_stralloc (filename);
 552   if (data == NULL)
 553     {
 554       /* Older Linux kernels did not support /proc/PID/smaps.  */
 555       xsnprintf (filename, sizeof filename,
 556                  "/proc/%d/maps", current_inferior ()->pid);
 557       data = target_fileio_read_stralloc (filename);
 558     }
 559   if (data)
 560     {
 561       struct cleanup *cleanup = make_cleanup (xfree, data);
 562       char *line;
 563
 564       line = strtok (data, "\n");
 565       while (line)
 566         {
 567           ULONGEST addr, endaddr, offset, inode;
 568           const char *permissions, *device, *filename;
 569           size_t permissions_len, device_len;
 570           int read, write, exec;
 571           int modified = 0, has_anonymous = 0;
 572
 573           read_mapping (line, &addr, &endaddr, &permissions, &permissions_len,
 574                         &offset, &device, &device_len, &inode, &filename);
 575
 576           /* Decode permissions.  */
 577           read = (memchr (permissions, 'r', permissions_len) != 0);
 578           write = (memchr (permissions, 'w', permissions_len) != 0);
 579           exec = (memchr (permissions, 'x', permissions_len) != 0);
 580
 581           /* Try to detect if region was modified by parsing smaps counters.  */
 582           for (line = strtok (NULL, "\n");
 583                line && line[0] >= 'A' && line[0] <= 'Z';
 584                line = strtok (NULL, "\n"))
 585             {
 586               char keyword[64 + 1];
 587               unsigned long number;
 588
 589               if (sscanf (line, "%64s%lu kB\n", keyword, &number) != 2)
 590                 {
 591                   warning (_("Error parsing {s,}maps file '%s'"), filename);
 592                   break;
 593                 }
 594               if (strcmp (keyword, "Anonymous:") == 0)
 595                 has_anonymous = 1;
 596               if (number != 0 && (strcmp (keyword, "Shared_Dirty:") == 0
 597                                   || strcmp (keyword, "Private_Dirty:") == 0
 598                                   || strcmp (keyword, "Swap:") == 0
 599                                   || strcmp (keyword, "Anonymous:") == 0))
 600                 modified = 1;
 601             }
 602
 603           /* Older Linux kernels did not support the "Anonymous:" counter.
 604              If it is missing, we can't be sure - dump all the pages.  */
 605           if (!has_anonymous)
 606             modified = 1;
 607
 608           /* Invoke the callback function to create the corefile segment.  */
 609           func (addr, endaddr - addr, read, write, exec, modified, obfd);
 610         }
 611
 612       do_cleanups (cleanup);
 613       return 0;
 614     }
 615
 616   return 1;
 617 }
 618
 619 /* Determine which signal stopped execution.  */
 620
 621 static int
 622 find_signalled_thread (struct thread_info *info, void *data)
 623 {
 624   if (info->suspend.stop_signal != GDB_SIGNAL_0
 625       && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
 626     return 1;
 627
 628   return 0;
 629 }
 630
 631 static enum gdb_signal
 632 find_stop_signal (void)
 633 {
 634   struct thread_info *info =
 635     iterate_over_threads (find_signalled_thread, NULL);
 636
 637   if (info)
 638     return info->suspend.stop_signal;
 639   else
 640     return GDB_SIGNAL_0;
 641 }
 642
 643 /* Generate corefile notes for SPU contexts.  */
 644
 645 static char *
 646 linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
 647 {
 648   static const char *spu_files[] =
 649     {
 650       "object-id",
 651       "mem",
 652       "regs",
 653       "fpcr",
 654       "lslr",
 655       "decr",
 656       "decr_status",
 657       "signal1",
 658       "signal1_type",
 659       "signal2",
 660       "signal2_type",
 661       "event_mask",
 662       "event_status",
 663       "mbox_info",
 664       "ibox_info",
 665       "wbox_info",
 666       "dma_info",
 667       "proxydma_info",
 668    };
 669
 670   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 671   gdb_byte *spu_ids;
 672   LONGEST i, j, size;
 673
 674   /* Determine list of SPU ids.  */
 675   size = target_read_alloc (&current_target, TARGET_OBJECT_SPU,
 676                             NULL, &spu_ids);
 677
 678   /* Generate corefile notes for each SPU file.  */
 679   for (i = 0; i < size; i += 4)
 680     {
 681       int fd = extract_unsigned_integer (spu_ids + i, 4, byte_order);
 682
 683       for (j = 0; j < sizeof (spu_files) / sizeof (spu_files[0]); j++)
 684         {
 685           char annex[32], note_name[32];
 686           gdb_byte *spu_data;
 687           LONGEST spu_len;
 688
 689           xsnprintf (annex, sizeof annex, "%d/%s", fd, spu_files[j]);
 690           spu_len = target_read_alloc (&current_target, TARGET_OBJECT_SPU,
 691                                        annex, &spu_data);
 692           if (spu_len > 0)
 693             {
 694               xsnprintf (note_name, sizeof note_name, "SPU/%s", annex);
 695               note_data = elfcore_write_note (obfd, note_data, note_size,
 696                                               note_name, NT_SPU,
 697                                               spu_data, spu_len);
 698               xfree (spu_data);
 699
 700               if (!note_data)
 701                 {
 702                   xfree (spu_ids);
 703                   return NULL;
 704                 }
 705             }
 706         }
 707     }
 708
 709   if (size > 0)
 710     xfree (spu_ids);
 711
 712   return note_data;
 713 }
 714
 715 /* Records the thread's register state for the corefile note
 716    section.  */
 717
 718 static char *
 719 linux_collect_thread_registers (const struct regcache *regcache,
 720                                 ptid_t ptid, bfd *obfd,
 721                                 char *note_data, int *note_size,
 722                                 enum gdb_signal stop_signal)
 723 {
 724   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 725   struct core_regset_section *sect_list;
 726   unsigned long lwp;
 727
 728   sect_list = gdbarch_core_regset_sections (gdbarch);
 729   gdb_assert (sect_list);
 730
 731   /* For remote targets the LWP may not be available, so use the TID.  */
 732   lwp = ptid_get_lwp (ptid);
 733   if (!lwp)
 734     lwp = ptid_get_tid (ptid);
 735
 736   while (sect_list->sect_name != NULL)
 737     {
 738       const struct regset *regset;
 739       char *buf;
 740
 741       regset = gdbarch_regset_from_core_section (gdbarch,
 742                                                  sect_list->sect_name,
 743                                                  sect_list->size);
 744       gdb_assert (regset && regset->collect_regset);
 745
 746       buf = xmalloc (sect_list->size);
 747       regset->collect_regset (regset, regcache, -1, buf, sect_list->size);
 748
 749       /* PRSTATUS still needs to be treated specially.  */
 750       if (strcmp (sect_list->sect_name, ".reg") == 0)
 751         note_data = (char *) elfcore_write_prstatus
 752                                (obfd, note_data, note_size, lwp,
 753                                 gdb_signal_to_host (stop_signal), buf);
 754       else
 755         note_data = (char *) elfcore_write_register_note
 756                                (obfd, note_data, note_size,
 757                                 sect_list->sect_name, buf, sect_list->size);
 758       xfree (buf);
 759       sect_list++;
 760
 761       if (!note_data)
 762         return NULL;
 763     }
 764
 765   return note_data;
 766 }
 767
 768 /* Fetch the siginfo data for the current thread, if it exists.  If
 769    there is no data, or we could not read it, return NULL.  Otherwise,
 770    return a newly malloc'd buffer holding the data and fill in *SIZE
 771    with the size of the data.  The caller is responsible for freeing
 772    the data.  */
 773
 774 static gdb_byte *
 775 linux_get_siginfo_data (struct gdbarch *gdbarch, LONGEST *size)
 776 {
 777   struct type *siginfo_type;
 778   gdb_byte *buf;
 779   LONGEST bytes_read;
 780   struct cleanup *cleanups;
 781
 782   if (!gdbarch_get_siginfo_type_p (gdbarch))
 783     return NULL;
 784
 785   siginfo_type = gdbarch_get_siginfo_type (gdbarch);
 786
 787   buf = xmalloc (TYPE_LENGTH (siginfo_type));
 788   cleanups = make_cleanup (xfree, buf);
 789
 790   bytes_read = target_read (&current_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
 791                             buf, 0, TYPE_LENGTH (siginfo_type));
 792   if (bytes_read == TYPE_LENGTH (siginfo_type))
 793     {
 794       discard_cleanups (cleanups);
 795       *size = bytes_read;
 796     }
 797   else
 798     {
 799       do_cleanups (cleanups);
 800       buf = NULL;
 801     }
 802
 803   return buf;
 804 }
 805
 806 struct linux_corefile_thread_data
 807 {
 808   struct gdbarch *gdbarch;
 809   int pid;
 810   bfd *obfd;
 811   char *note_data;
 812   int *note_size;
 813   int num_notes;
 814   enum gdb_signal stop_signal;
 815   linux_collect_thread_registers_ftype collect;
 816 };
 817
 818 /* Called by gdbthread.c once per thread.  Records the thread's
 819    register state for the corefile note section.  */
 820
 821 static int
 822 linux_corefile_thread_callback (struct thread_info *info, void *data)
 823 {
 824   struct linux_corefile_thread_data *args = data;
 825
 826   if (ptid_get_pid (info->ptid) == args->pid)
 827     {
 828       struct cleanup *old_chain;
 829       struct regcache *regcache;
 830       gdb_byte *siginfo_data;
 831       LONGEST siginfo_size;
 832
 833       regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
 834
 835       old_chain = save_inferior_ptid ();
 836       inferior_ptid = info->ptid;
 837       target_fetch_registers (regcache, -1);
 838       siginfo_data = linux_get_siginfo_data (args->gdbarch, &siginfo_size);
 839       do_cleanups (old_chain);
 840
 841       old_chain = make_cleanup (xfree, siginfo_data);
 842
 843       args->note_data = args->collect (regcache, info->ptid, args->obfd,
 844                                        args->note_data, args->note_size,
 845                                        args->stop_signal);
 846       args->num_notes++;
 847
 848       if (siginfo_data != NULL)
 849         {
 850           args->note_data = elfcore_write_note (args->obfd,
 851                                                 args->note_data,
 852                                                 args->note_size,
 853                                                 "CORE", NT_SIGINFO,
 854                                                 siginfo_data, siginfo_size);
 855           args->num_notes++;
 856         }
 857
 858       do_cleanups (old_chain);
 859     }
 860
 861   return !args->note_data;
 862 }
 863
 864 /* Fills the "to_make_corefile_note" target vector.  Builds the note
 865    section for a corefile, and returns it in a malloc buffer.  */
 866
 867 char *
 868 linux_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size,
 869                            linux_collect_thread_registers_ftype collect)
 870 {
 871   struct linux_corefile_thread_data thread_args;
 872   char *note_data = NULL;
 873   gdb_byte *auxv;
 874   int auxv_len;
 875
 876   /* Process information.  */
 877   if (get_exec_file (0))
 878     {
 879       const char *fname = lbasename (get_exec_file (0));
 880       char *psargs = xstrdup (fname);
 881
 882       if (get_inferior_args ())
 883         psargs = reconcat (psargs, psargs, " ", get_inferior_args (),
 884                            (char *) NULL);
 885
 886       note_data = elfcore_write_prpsinfo (obfd, note_data, note_size,
 887                                           fname, psargs);
 888       xfree (psargs);
 889
 890       if (!note_data)
 891         return NULL;
 892     }
 893
 894   /* Thread register information.  */
 895   thread_args.gdbarch = gdbarch;
 896   thread_args.pid = ptid_get_pid (inferior_ptid);
 897   thread_args.obfd = obfd;
 898   thread_args.note_data = note_data;
 899   thread_args.note_size = note_size;
 900   thread_args.num_notes = 0;
 901   thread_args.stop_signal = find_stop_signal ();
 902   thread_args.collect = collect;
 903   iterate_over_threads (linux_corefile_thread_callback, &thread_args);
 904   note_data = thread_args.note_data;
 905   if (!note_data)
 906     return NULL;
 907
 908   /* Auxillary vector.  */
 909   auxv_len = target_read_alloc (&current_target, TARGET_OBJECT_AUXV,
 910                                 NULL, &auxv);
 911   if (auxv_len > 0)
 912     {
 913       note_data = elfcore_write_note (obfd, note_data, note_size,
 914                                       "CORE", NT_AUXV, auxv, auxv_len);
 915       xfree (auxv);
 916
 917       if (!note_data)
 918         return NULL;
 919     }
 920
 921   /* SPU information.  */
 922   note_data = linux_spu_make_corefile_notes (obfd, note_data, note_size);
 923   if (!note_data)
 924     return NULL;
 925
 926   make_cleanup (xfree, note_data);
 927   return note_data;
 928 }
 929
 930 static char *
 931 linux_make_corefile_notes_1 (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
 932 {
 933   /* FIXME: uweigand/2011-10-06: Once all GNU/Linux architectures have been
 934      converted to gdbarch_core_regset_sections, we no longer need to fall back
 935      to the target method at this point.  */
 936
 937   if (!gdbarch_core_regset_sections (gdbarch))
 938     return target_make_corefile_notes (obfd, note_size);
 939   else
 940     return linux_make_corefile_notes (gdbarch, obfd, note_size,
 941                                       linux_collect_thread_registers);
 942 }
 943
 944 /* To be called from the various GDB_OSABI_LINUX handlers for the
 945    various GNU/Linux architectures and machine types.  */
 946
 947 void
 948 linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 949 {
 950   set_gdbarch_core_pid_to_str (gdbarch, linux_core_pid_to_str);
 951   set_gdbarch_info_proc (gdbarch, linux_info_proc);
 952   set_gdbarch_find_memory_regions (gdbarch, linux_find_memory_regions);
 953   set_gdbarch_make_corefile_notes (gdbarch, linux_make_corefile_notes_1);
 954   set_gdbarch_has_shared_address_space (gdbarch,
 955                                         linux_has_shared_address_space);
 956 }
 957
 958 /* Provide a prototype to silence -Wmissing-prototypes.  */
 959 extern initialize_file_ftype _initialize_linux_tdep;
 960
 961 void
 962 _initialize_linux_tdep (void)
 963 {
 964   linux_gdbarch_data_handle =
 965     gdbarch_data_register_post_init (init_linux_gdbarch_data);
 966 }