GDB (xrefs)
/tmp/gdb-7.10/gdb/linux-tdep.c
Go to the documentation of this file.
1 /* Target-dependent code for GNU/Linux, architecture independent.
2 
3  Copyright (C) 2009-2015 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 "observer.h"
36 #include "objfiles.h"
37 #include "infcall.h"
38 #include "gdbcmd.h"
39 #include "gdb_regex.h"
40 
41 #include <ctype.h>
42 
43 /* This enum represents the values that the user can choose when
44  informing the Linux kernel about which memory mappings will be
45  dumped in a corefile. They are described in the file
46  Documentation/filesystems/proc.txt, inside the Linux kernel
47  tree. */
48 
50  {
58  };
59 
60 /* This struct is used to map flags found in the "VmFlags:" field (in
61  the /proc/<PID>/smaps file). */
62 
64  {
65  /* Zero if this structure has not been initialized yet. It
66  probably means that the Linux kernel being used does not emit
67  the "VmFlags:" field on "/proc/PID/smaps". */
68 
69  unsigned int initialized_p : 1;
70 
71  /* Memory mapped I/O area (VM_IO, "io"). */
72 
73  unsigned int io_page : 1;
74 
75  /* Area uses huge TLB pages (VM_HUGETLB, "ht"). */
76 
77  unsigned int uses_huge_tlb : 1;
78 
79  /* Do not include this memory region on the coredump (VM_DONTDUMP, "dd"). */
80 
81  unsigned int exclude_coredump : 1;
82 
83  /* Is this a MAP_SHARED mapping (VM_SHARED, "sh"). */
84 
85  unsigned int shared_mapping : 1;
86  };
87 
88 /* Whether to take the /proc/PID/coredump_filter into account when
89  generating a corefile. */
90 
91 static int use_coredump_filter = 1;
92 
93 /* This enum represents the signals' numbers on a generic architecture
94  running the Linux kernel. The definition of "generic" comes from
95  the file <include/uapi/asm-generic/signal.h>, from the Linux kernel
96  tree, which is the "de facto" implementation of signal numbers to
97  be used by new architecture ports.
98 
99  For those architectures which have differences between the generic
100  standard (e.g., Alpha), we define the different signals (and *only*
101  those) in the specific target-dependent file (e.g.,
102  alpha-linux-tdep.c, for Alpha). Please refer to the architecture's
103  tdep file for more information.
104 
105  ARM deserves a special mention here. On the file
106  <arch/arm/include/uapi/asm/signal.h>, it defines only one different
107  (and ARM-only) signal, which is SIGSWI, with the same number as
108  SIGRTMIN. This signal is used only for a very specific target,
109  called ArthurOS (from RISCOS). Therefore, we do not handle it on
110  the ARM-tdep file, and we can safely use the generic signal handler
111  here for ARM targets.
112 
113  As stated above, this enum is derived from
114  <include/uapi/asm-generic/signal.h>, from the Linux kernel
115  tree. */
116 
117 enum
118  {
153 
156  };
157 
159 
161  {
163  };
164 
165 static void *
167 {
168  return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct linux_gdbarch_data);
169 }
170 
171 static struct linux_gdbarch_data *
173 {
174  return gdbarch_data (gdbarch, linux_gdbarch_data_handle);
175 }
176 
177 /* Per-inferior data key. */
178 static const struct inferior_data *linux_inferior_data;
179 
180 /* Linux-specific cached data. This is used by GDB for caching
181  purposes for each inferior. This helps reduce the overhead of
182  transfering data from a remote target to the local host. */
184 {
185  /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
186  if VSYSCALL_RANGE_P is positive. This is cached because getting
187  at this info requires an auxv lookup (which is itself cached),
188  and looking through the inferior's mappings (which change
189  throughout execution and therefore cannot be cached). */
191 
192  /* Zero if we haven't tried looking up the vsyscall's range before
193  yet. Positive if we tried looking it up, and found it. Negative
194  if we tried looking it up but failed. */
196 };
197 
198 /* Frees whatever allocated space there is to be freed and sets INF's
199  linux cache data pointer to NULL. */
200 
201 static void
203 {
204  struct linux_info *info;
205 
206  info = inferior_data (inf, linux_inferior_data);
207  if (info != NULL)
208  {
209  xfree (info);
210  set_inferior_data (inf, linux_inferior_data, NULL);
211  }
212 }
213 
214 /* Handles the cleanup of the linux cache for inferior INF. ARG is
215  ignored. Callback for the inferior_appeared and inferior_exit
216  events. */
217 
218 static void
220 {
222 }
223 
224 /* Fetch the linux cache info for INF. This function always returns a
225  valid INFO pointer. */
226 
227 static struct linux_info *
229 {
230  struct linux_info *info;
231  struct inferior *inf = current_inferior ();
232 
233  info = inferior_data (inf, linux_inferior_data);
234  if (info == NULL)
235  {
236  info = XCNEW (struct linux_info);
237  set_inferior_data (inf, linux_inferior_data, info);
238  }
239 
240  return info;
241 }
242 
243 /* This function is suitable for architectures that don't
244  extend/override the standard siginfo structure. */
245 
246 static struct type *
248 {
250  struct type *int_type, *uint_type, *long_type, *void_ptr_type;
251  struct type *uid_type, *pid_type;
252  struct type *sigval_type, *clock_type;
253  struct type *siginfo_type, *sifields_type;
254  struct type *type;
255 
256  linux_gdbarch_data = get_linux_gdbarch_data (gdbarch);
257  if (linux_gdbarch_data->siginfo_type != NULL)
258  return linux_gdbarch_data->siginfo_type;
259 
260  int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
261  0, "int");
262  uint_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
263  1, "unsigned int");
264  long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
265  0, "long");
266  void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
267 
268  /* sival_t */
269  sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
270  TYPE_NAME (sigval_type) = xstrdup ("sigval_t");
271  append_composite_type_field (sigval_type, "sival_int", int_type);
272  append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
273 
274  /* __pid_t */
275  pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
276  TYPE_LENGTH (int_type), "__pid_t");
277  TYPE_TARGET_TYPE (pid_type) = int_type;
278  TYPE_TARGET_STUB (pid_type) = 1;
279 
280  /* __uid_t */
281  uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
282  TYPE_LENGTH (uint_type), "__uid_t");
283  TYPE_TARGET_TYPE (uid_type) = uint_type;
284  TYPE_TARGET_STUB (uid_type) = 1;
285 
286  /* __clock_t */
287  clock_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
288  TYPE_LENGTH (long_type), "__clock_t");
289  TYPE_TARGET_TYPE (clock_type) = long_type;
290  TYPE_TARGET_STUB (clock_type) = 1;
291 
292  /* _sifields */
293  sifields_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
294 
295  {
296  const int si_max_size = 128;
297  int si_pad_size;
298  int size_of_int = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
299 
300  /* _pad */
301  if (gdbarch_ptr_bit (gdbarch) == 64)
302  si_pad_size = (si_max_size / size_of_int) - 4;
303  else
304  si_pad_size = (si_max_size / size_of_int) - 3;
305  append_composite_type_field (sifields_type, "_pad",
306  init_vector_type (int_type, si_pad_size));
307  }
308 
309  /* _kill */
310  type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
311  append_composite_type_field (type, "si_pid", pid_type);
312  append_composite_type_field (type, "si_uid", uid_type);
313  append_composite_type_field (sifields_type, "_kill", type);
314 
315  /* _timer */
316  type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
317  append_composite_type_field (type, "si_tid", int_type);
318  append_composite_type_field (type, "si_overrun", int_type);
319  append_composite_type_field (type, "si_sigval", sigval_type);
320  append_composite_type_field (sifields_type, "_timer", type);
321 
322  /* _rt */
323  type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
324  append_composite_type_field (type, "si_pid", pid_type);
325  append_composite_type_field (type, "si_uid", uid_type);
326  append_composite_type_field (type, "si_sigval", sigval_type);
327  append_composite_type_field (sifields_type, "_rt", type);
328 
329  /* _sigchld */
330  type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
331  append_composite_type_field (type, "si_pid", pid_type);
332  append_composite_type_field (type, "si_uid", uid_type);
333  append_composite_type_field (type, "si_status", int_type);
334  append_composite_type_field (type, "si_utime", clock_type);
335  append_composite_type_field (type, "si_stime", clock_type);
336  append_composite_type_field (sifields_type, "_sigchld", type);
337 
338  /* _sigfault */
339  type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
340  append_composite_type_field (type, "si_addr", void_ptr_type);
341  append_composite_type_field (sifields_type, "_sigfault", type);
342 
343  /* _sigpoll */
344  type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
345  append_composite_type_field (type, "si_band", long_type);
346  append_composite_type_field (type, "si_fd", int_type);
347  append_composite_type_field (sifields_type, "_sigpoll", type);
348 
349  /* struct siginfo */
350  siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
351  TYPE_NAME (siginfo_type) = xstrdup ("siginfo");
352  append_composite_type_field (siginfo_type, "si_signo", int_type);
353  append_composite_type_field (siginfo_type, "si_errno", int_type);
354  append_composite_type_field (siginfo_type, "si_code", int_type);
356  "_sifields", sifields_type,
357  TYPE_LENGTH (long_type));
358 
359  linux_gdbarch_data->siginfo_type = siginfo_type;
360 
361  return siginfo_type;
362 }
363 
364 /* Return true if the target is running on uClinux instead of normal
365  Linux kernel. */
366 
367 int
369 {
371 
372  return (target_auxv_search (&current_target, AT_NULL, &dummy) > 0
373  && target_auxv_search (&current_target, AT_PAGESZ, &dummy) == 0);
374 }
375 
376 static int
378 {
379  return linux_is_uclinux ();
380 }
381 
382 /* This is how we want PTIDs from core files to be printed. */
383 
384 static char *
386 {
387  static char buf[80];
388 
389  if (ptid_get_lwp (ptid) != 0)
390  {
391  snprintf (buf, sizeof (buf), "LWP %ld", ptid_get_lwp (ptid));
392  return buf;
393  }
394 
395  return normal_pid_to_str (ptid);
396 }
397 
398 /* Service function for corefiles and info proc. */
399 
400 static void
401 read_mapping (const char *line,
402  ULONGEST *addr, ULONGEST *endaddr,
403  const char **permissions, size_t *permissions_len,
404  ULONGEST *offset,
405  const char **device, size_t *device_len,
406  ULONGEST *inode,
407  const char **filename)
408 {
409  const char *p = line;
410 
411  *addr = strtoulst (p, &p, 16);
412  if (*p == '-')
413  p++;
414  *endaddr = strtoulst (p, &p, 16);
415 
416  p = skip_spaces_const (p);
417  *permissions = p;
418  while (*p && !isspace (*p))
419  p++;
420  *permissions_len = p - *permissions;
421 
422  *offset = strtoulst (p, &p, 16);
423 
424  p = skip_spaces_const (p);
425  *device = p;
426  while (*p && !isspace (*p))
427  p++;
428  *device_len = p - *device;
429 
430  *inode = strtoulst (p, &p, 10);
431 
432  p = skip_spaces_const (p);
433  *filename = p;
434 }
435 
436 /* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
437 
438  This function was based on the documentation found on
439  <Documentation/filesystems/proc.txt>, on the Linux kernel.
440 
441  Linux kernels before commit
442  834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
443  field on smaps. */
444 
445 static void
446 decode_vmflags (char *p, struct smaps_vmflags *v)
447 {
448  char *saveptr = NULL;
449  const char *s;
450 
451  v->initialized_p = 1;
452  p = skip_to_space (p);
453  p = skip_spaces (p);
454 
455  for (s = strtok_r (p, " ", &saveptr);
456  s != NULL;
457  s = strtok_r (NULL, " ", &saveptr))
458  {
459  if (strcmp (s, "io") == 0)
460  v->io_page = 1;
461  else if (strcmp (s, "ht") == 0)
462  v->uses_huge_tlb = 1;
463  else if (strcmp (s, "dd") == 0)
464  v->exclude_coredump = 1;
465  else if (strcmp (s, "sh") == 0)
466  v->shared_mapping = 1;
467  }
468 }
469 
470 /* Return 1 if the memory mapping is anonymous, 0 otherwise.
471 
472  FILENAME is the name of the file present in the first line of the
473  memory mapping, in the "/proc/PID/smaps" output. For example, if
474  the first line is:
475 
476  7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
477 
478  Then FILENAME will be "/path/to/file". */
479 
480 static int
481 mapping_is_anonymous_p (const char *filename)
482 {
483  static regex_t dev_zero_regex, shmem_file_regex, file_deleted_regex;
484  static int init_regex_p = 0;
485 
486  if (!init_regex_p)
487  {
488  struct cleanup *c = make_cleanup (null_cleanup, NULL);
489 
490  /* Let's be pessimistic and assume there will be an error while
491  compiling the regex'es. */
492  init_regex_p = -1;
493 
494  /* DEV_ZERO_REGEX matches "/dev/zero" filenames (with or
495  without the "(deleted)" string in the end). We know for
496  sure, based on the Linux kernel code, that memory mappings
497  whose associated filename is "/dev/zero" are guaranteed to be
498  MAP_ANONYMOUS. */
499  compile_rx_or_error (&dev_zero_regex, "^/dev/zero\\( (deleted)\\)\\?$",
500  _("Could not compile regex to match /dev/zero "
501  "filename"));
502  /* SHMEM_FILE_REGEX matches "/SYSV%08x" filenames (with or
503  without the "(deleted)" string in the end). These filenames
504  refer to shared memory (shmem), and memory mappings
505  associated with them are MAP_ANONYMOUS as well. */
506  compile_rx_or_error (&shmem_file_regex,
507  "^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$",
508  _("Could not compile regex to match shmem "
509  "filenames"));
510  /* FILE_DELETED_REGEX is a heuristic we use to try to mimic the
511  Linux kernel's 'n_link == 0' code, which is responsible to
512  decide if it is dealing with a 'MAP_SHARED | MAP_ANONYMOUS'
513  mapping. In other words, if FILE_DELETED_REGEX matches, it
514  does not necessarily mean that we are dealing with an
515  anonymous shared mapping. However, there is no easy way to
516  detect this currently, so this is the best approximation we
517  have.
518 
519  As a result, GDB will dump readonly pages of deleted
520  executables when using the default value of coredump_filter
521  (0x33), while the Linux kernel will not dump those pages.
522  But we can live with that. */
523  compile_rx_or_error (&file_deleted_regex, " (deleted)$",
524  _("Could not compile regex to match "
525  "'<file> (deleted)'"));
526  /* We will never release these regexes, so just discard the
527  cleanups. */
528  discard_cleanups (c);
529 
530  /* If we reached this point, then everything succeeded. */
531  init_regex_p = 1;
532  }
533 
534  if (init_regex_p == -1)
535  {
536  const char deleted[] = " (deleted)";
537  size_t del_len = sizeof (deleted) - 1;
538  size_t filename_len = strlen (filename);
539 
540  /* There was an error while compiling the regex'es above. In
541  order to try to give some reliable information to the caller,
542  we just try to find the string " (deleted)" in the filename.
543  If we managed to find it, then we assume the mapping is
544  anonymous. */
545  return (filename_len >= del_len
546  && strcmp (filename + filename_len - del_len, deleted) == 0);
547  }
548 
549  if (*filename == '\0'
550  || regexec (&dev_zero_regex, filename, 0, NULL, 0) == 0
551  || regexec (&shmem_file_regex, filename, 0, NULL, 0) == 0
552  || regexec (&file_deleted_regex, filename, 0, NULL, 0) == 0)
553  return 1;
554 
555  return 0;
556 }
557 
558 /* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
559  MAYBE_PRIVATE_P, and MAPPING_ANONYMOUS_P) should not be dumped, or
560  greater than 0 if it should.
561 
562  In a nutshell, this is the logic that we follow in order to decide
563  if a mapping should be dumped or not.
564 
565  - If the mapping is associated to a file whose name ends with
566  " (deleted)", or if the file is "/dev/zero", or if it is
567  "/SYSV%08x" (shared memory), or if there is no file associated
568  with it, or if the AnonHugePages: or the Anonymous: fields in the
569  /proc/PID/smaps have contents, then GDB considers this mapping to
570  be anonymous. Otherwise, GDB considers this mapping to be a
571  file-backed mapping (because there will be a file associated with
572  it).
573 
574  It is worth mentioning that, from all those checks described
575  above, the most fragile is the one to see if the file name ends
576  with " (deleted)". This does not necessarily mean that the
577  mapping is anonymous, because the deleted file associated with
578  the mapping may have been a hard link to another file, for
579  example. The Linux kernel checks to see if "i_nlink == 0", but
580  GDB cannot easily (and normally) do this check (iff running as
581  root, it could find the mapping in /proc/PID/map_files/ and
582  determine whether there still are other hard links to the
583  inode/file). Therefore, we made a compromise here, and we assume
584  that if the file name ends with " (deleted)", then the mapping is
585  indeed anonymous. FWIW, this is something the Linux kernel could
586  do better: expose this information in a more direct way.
587 
588  - If we see the flag "sh" in the "VmFlags:" field (in
589  /proc/PID/smaps), then certainly the memory mapping is shared
590  (VM_SHARED). If we have access to the VmFlags, and we don't see
591  the "sh" there, then certainly the mapping is private. However,
592  Linux kernels before commit
593  834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
594  "VmFlags:" field; in that case, we use another heuristic: if we
595  see 'p' in the permission flags, then we assume that the mapping
596  is private, even though the presence of the 's' flag there would
597  mean VM_MAYSHARE, which means the mapping could still be private.
598  This should work OK enough, however. */
599 
600 static int
602  int maybe_private_p, int mapping_anon_p, int mapping_file_p,
603  const char *filename)
604 {
605  /* Initially, we trust in what we received from our caller. This
606  value may not be very precise (i.e., it was probably gathered
607  from the permission line in the /proc/PID/smaps list, which
608  actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
609  what we have until we take a look at the "VmFlags:" field
610  (assuming that the version of the Linux kernel being used
611  supports it, of course). */
612  int private_p = maybe_private_p;
613 
614  /* We always dump vDSO and vsyscall mappings, because it's likely that
615  there'll be no file to read the contents from at core load time.
616  The kernel does the same. */
617  if (strcmp ("[vdso]", filename) == 0
618  || strcmp ("[vsyscall]", filename) == 0)
619  return 1;
620 
621  if (v->initialized_p)
622  {
623  /* We never dump I/O mappings. */
624  if (v->io_page)
625  return 0;
626 
627  /* Check if we should exclude this mapping. */
628  if (v->exclude_coredump)
629  return 0;
630 
631  /* Update our notion of whether this mapping is shared or
632  private based on a trustworthy value. */
633  private_p = !v->shared_mapping;
634 
635  /* HugeTLB checking. */
636  if (v->uses_huge_tlb)
637  {
638  if ((private_p && (filterflags & COREFILTER_HUGETLB_PRIVATE))
639  || (!private_p && (filterflags & COREFILTER_HUGETLB_SHARED)))
640  return 1;
641 
642  return 0;
643  }
644  }
645 
646  if (private_p)
647  {
648  if (mapping_anon_p && mapping_file_p)
649  {
650  /* This is a special situation. It can happen when we see a
651  mapping that is file-backed, but that contains anonymous
652  pages. */
653  return ((filterflags & COREFILTER_ANON_PRIVATE) != 0
654  || (filterflags & COREFILTER_MAPPED_PRIVATE) != 0);
655  }
656  else if (mapping_anon_p)
657  return (filterflags & COREFILTER_ANON_PRIVATE) != 0;
658  else
659  return (filterflags & COREFILTER_MAPPED_PRIVATE) != 0;
660  }
661  else
662  {
663  if (mapping_anon_p && mapping_file_p)
664  {
665  /* This is a special situation. It can happen when we see a
666  mapping that is file-backed, but that contains anonymous
667  pages. */
668  return ((filterflags & COREFILTER_ANON_SHARED) != 0
669  || (filterflags & COREFILTER_MAPPED_SHARED) != 0);
670  }
671  else if (mapping_anon_p)
672  return (filterflags & COREFILTER_ANON_SHARED) != 0;
673  else
674  return (filterflags & COREFILTER_MAPPED_SHARED) != 0;
675  }
676 }
677 
678 /* Implement the "info proc" command. */
679 
680 static void
681 linux_info_proc (struct gdbarch *gdbarch, const char *args,
682  enum info_proc_what what)
683 {
684  /* A long is used for pid instead of an int to avoid a loss of precision
685  compiler warning from the output of strtoul. */
686  long pid;
687  int cmdline_f = (what == IP_MINIMAL || what == IP_CMDLINE || what == IP_ALL);
688  int cwd_f = (what == IP_MINIMAL || what == IP_CWD || what == IP_ALL);
689  int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
690  int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
691  int status_f = (what == IP_STATUS || what == IP_ALL);
692  int stat_f = (what == IP_STAT || what == IP_ALL);
693  char filename[100];
694  char *data;
695  int target_errno;
696 
697  if (args && isdigit (args[0]))
698  {
699  char *tem;
700 
701  pid = strtoul (args, &tem, 10);
702  args = tem;
703  }
704  else
705  {
707  error (_("No current process: you must name one."));
708  if (current_inferior ()->fake_pid_p)
709  error (_("Can't determine the current process's PID: you must name one."));
710 
711  pid = current_inferior ()->pid;
712  }
713 
714  args = skip_spaces_const (args);
715  if (args && args[0])
716  error (_("Too many parameters: %s"), args);
717 
718  printf_filtered (_("process %ld\n"), pid);
719  if (cmdline_f)
720  {
721  xsnprintf (filename, sizeof filename, "/proc/%ld/cmdline", pid);
722  data = target_fileio_read_stralloc (NULL, filename);
723  if (data)
724  {
725  struct cleanup *cleanup = make_cleanup (xfree, data);
726  printf_filtered ("cmdline = '%s'\n", data);
727  do_cleanups (cleanup);
728  }
729  else
730  warning (_("unable to open /proc file '%s'"), filename);
731  }
732  if (cwd_f)
733  {
734  xsnprintf (filename, sizeof filename, "/proc/%ld/cwd", pid);
735  data = target_fileio_readlink (NULL, filename, &target_errno);
736  if (data)
737  {
738  struct cleanup *cleanup = make_cleanup (xfree, data);
739  printf_filtered ("cwd = '%s'\n", data);
740  do_cleanups (cleanup);
741  }
742  else
743  warning (_("unable to read link '%s'"), filename);
744  }
745  if (exe_f)
746  {
747  xsnprintf (filename, sizeof filename, "/proc/%ld/exe", pid);
748  data = target_fileio_readlink (NULL, filename, &target_errno);
749  if (data)
750  {
751  struct cleanup *cleanup = make_cleanup (xfree, data);
752  printf_filtered ("exe = '%s'\n", data);
753  do_cleanups (cleanup);
754  }
755  else
756  warning (_("unable to read link '%s'"), filename);
757  }
758  if (mappings_f)
759  {
760  xsnprintf (filename, sizeof filename, "/proc/%ld/maps", pid);
761  data = target_fileio_read_stralloc (NULL, filename);
762  if (data)
763  {
764  struct cleanup *cleanup = make_cleanup (xfree, data);
765  char *line;
766 
767  printf_filtered (_("Mapped address spaces:\n\n"));
768  if (gdbarch_addr_bit (gdbarch) == 32)
769  {
770  printf_filtered ("\t%10s %10s %10s %10s %s\n",
771  "Start Addr",
772  " End Addr",
773  " Size", " Offset", "objfile");
774  }
775  else
776  {
777  printf_filtered (" %18s %18s %10s %10s %s\n",
778  "Start Addr",
779  " End Addr",
780  " Size", " Offset", "objfile");
781  }
782 
783  for (line = strtok (data, "\n"); line; line = strtok (NULL, "\n"))
784  {
785  ULONGEST addr, endaddr, offset, inode;
786  const char *permissions, *device, *filename;
787  size_t permissions_len, device_len;
788 
789  read_mapping (line, &addr, &endaddr,
790  &permissions, &permissions_len,
791  &offset, &device, &device_len,
792  &inode, &filename);
793 
794  if (gdbarch_addr_bit (gdbarch) == 32)
795  {
796  printf_filtered ("\t%10s %10s %10s %10s %s\n",
797  paddress (gdbarch, addr),
798  paddress (gdbarch, endaddr),
799  hex_string (endaddr - addr),
800  hex_string (offset),
801  *filename? filename : "");
802  }
803  else
804  {
805  printf_filtered (" %18s %18s %10s %10s %s\n",
806  paddress (gdbarch, addr),
807  paddress (gdbarch, endaddr),
808  hex_string (endaddr - addr),
809  hex_string (offset),
810  *filename? filename : "");
811  }
812  }
813 
814  do_cleanups (cleanup);
815  }
816  else
817  warning (_("unable to open /proc file '%s'"), filename);
818  }
819  if (status_f)
820  {
821  xsnprintf (filename, sizeof filename, "/proc/%ld/status", pid);
822  data = target_fileio_read_stralloc (NULL, filename);
823  if (data)
824  {
825  struct cleanup *cleanup = make_cleanup (xfree, data);
826  puts_filtered (data);
827  do_cleanups (cleanup);
828  }
829  else
830  warning (_("unable to open /proc file '%s'"), filename);
831  }
832  if (stat_f)
833  {
834  xsnprintf (filename, sizeof filename, "/proc/%ld/stat", pid);
835  data = target_fileio_read_stralloc (NULL, filename);
836  if (data)
837  {
838  struct cleanup *cleanup = make_cleanup (xfree, data);
839  const char *p = data;
840 
841  printf_filtered (_("Process: %s\n"),
842  pulongest (strtoulst (p, &p, 10)));
843 
844  p = skip_spaces_const (p);
845  if (*p == '(')
846  {
847  /* ps command also relies on no trailing fields
848  ever contain ')'. */
849  const char *ep = strrchr (p, ')');
850  if (ep != NULL)
851  {
852  printf_filtered ("Exec file: %.*s\n",
853  (int) (ep - p - 1), p + 1);
854  p = ep + 1;
855  }
856  }
857 
858  p = skip_spaces_const (p);
859  if (*p)
860  printf_filtered (_("State: %c\n"), *p++);
861 
862  if (*p)
863  printf_filtered (_("Parent process: %s\n"),
864  pulongest (strtoulst (p, &p, 10)));
865  if (*p)
866  printf_filtered (_("Process group: %s\n"),
867  pulongest (strtoulst (p, &p, 10)));
868  if (*p)
869  printf_filtered (_("Session id: %s\n"),
870  pulongest (strtoulst (p, &p, 10)));
871  if (*p)
872  printf_filtered (_("TTY: %s\n"),
873  pulongest (strtoulst (p, &p, 10)));
874  if (*p)
875  printf_filtered (_("TTY owner process group: %s\n"),
876  pulongest (strtoulst (p, &p, 10)));
877 
878  if (*p)
879  printf_filtered (_("Flags: %s\n"),
880  hex_string (strtoulst (p, &p, 10)));
881  if (*p)
882  printf_filtered (_("Minor faults (no memory page): %s\n"),
883  pulongest (strtoulst (p, &p, 10)));
884  if (*p)
885  printf_filtered (_("Minor faults, children: %s\n"),
886  pulongest (strtoulst (p, &p, 10)));
887  if (*p)
888  printf_filtered (_("Major faults (memory page faults): %s\n"),
889  pulongest (strtoulst (p, &p, 10)));
890  if (*p)
891  printf_filtered (_("Major faults, children: %s\n"),
892  pulongest (strtoulst (p, &p, 10)));
893  if (*p)
894  printf_filtered (_("utime: %s\n"),
895  pulongest (strtoulst (p, &p, 10)));
896  if (*p)
897  printf_filtered (_("stime: %s\n"),
898  pulongest (strtoulst (p, &p, 10)));
899  if (*p)
900  printf_filtered (_("utime, children: %s\n"),
901  pulongest (strtoulst (p, &p, 10)));
902  if (*p)
903  printf_filtered (_("stime, children: %s\n"),
904  pulongest (strtoulst (p, &p, 10)));
905  if (*p)
906  printf_filtered (_("jiffies remaining in current "
907  "time slice: %s\n"),
908  pulongest (strtoulst (p, &p, 10)));
909  if (*p)
910  printf_filtered (_("'nice' value: %s\n"),
911  pulongest (strtoulst (p, &p, 10)));
912  if (*p)
913  printf_filtered (_("jiffies until next timeout: %s\n"),
914  pulongest (strtoulst (p, &p, 10)));
915  if (*p)
916  printf_filtered (_("jiffies until next SIGALRM: %s\n"),
917  pulongest (strtoulst (p, &p, 10)));
918  if (*p)
919  printf_filtered (_("start time (jiffies since "
920  "system boot): %s\n"),
921  pulongest (strtoulst (p, &p, 10)));
922  if (*p)
923  printf_filtered (_("Virtual memory size: %s\n"),
924  pulongest (strtoulst (p, &p, 10)));
925  if (*p)
926  printf_filtered (_("Resident set size: %s\n"),
927  pulongest (strtoulst (p, &p, 10)));
928  if (*p)
929  printf_filtered (_("rlim: %s\n"),
930  pulongest (strtoulst (p, &p, 10)));
931  if (*p)
932  printf_filtered (_("Start of text: %s\n"),
933  hex_string (strtoulst (p, &p, 10)));
934  if (*p)
935  printf_filtered (_("End of text: %s\n"),
936  hex_string (strtoulst (p, &p, 10)));
937  if (*p)
938  printf_filtered (_("Start of stack: %s\n"),
939  hex_string (strtoulst (p, &p, 10)));
940 #if 0 /* Don't know how architecture-dependent the rest is...
941  Anyway the signal bitmap info is available from "status". */
942  if (*p)
943  printf_filtered (_("Kernel stack pointer: %s\n"),
944  hex_string (strtoulst (p, &p, 10)));
945  if (*p)
946  printf_filtered (_("Kernel instr pointer: %s\n"),
947  hex_string (strtoulst (p, &p, 10)));
948  if (*p)
949  printf_filtered (_("Pending signals bitmap: %s\n"),
950  hex_string (strtoulst (p, &p, 10)));
951  if (*p)
952  printf_filtered (_("Blocked signals bitmap: %s\n"),
953  hex_string (strtoulst (p, &p, 10)));
954  if (*p)
955  printf_filtered (_("Ignored signals bitmap: %s\n"),
956  hex_string (strtoulst (p, &p, 10)));
957  if (*p)
958  printf_filtered (_("Catched signals bitmap: %s\n"),
959  hex_string (strtoulst (p, &p, 10)));
960  if (*p)
961  printf_filtered (_("wchan (system call): %s\n"),
962  hex_string (strtoulst (p, &p, 10)));
963 #endif
964  do_cleanups (cleanup);
965  }
966  else
967  warning (_("unable to open /proc file '%s'"), filename);
968  }
969 }
970 
971 /* Implement "info proc mappings" for a corefile. */
972 
973 static void
974 linux_core_info_proc_mappings (struct gdbarch *gdbarch, const char *args)
975 {
976  asection *section;
977  ULONGEST count, page_size;
978  unsigned char *descdata, *filenames, *descend, *contents;
979  size_t note_size;
980  unsigned int addr_size_bits, addr_size;
981  struct cleanup *cleanup;
982  struct gdbarch *core_gdbarch = gdbarch_from_bfd (core_bfd);
983  /* We assume this for reading 64-bit core files. */
984  gdb_static_assert (sizeof (ULONGEST) >= 8);
985 
986  section = bfd_get_section_by_name (core_bfd, ".note.linuxcore.file");
987  if (section == NULL)
988  {
989  warning (_("unable to find mappings in core file"));
990  return;
991  }
992 
993  addr_size_bits = gdbarch_addr_bit (core_gdbarch);
994  addr_size = addr_size_bits / 8;
995  note_size = bfd_get_section_size (section);
996 
997  if (note_size < 2 * addr_size)
998  error (_("malformed core note - too short for header"));
999 
1000  contents = xmalloc (note_size);
1001  cleanup = make_cleanup (xfree, contents);
1002  if (!bfd_get_section_contents (core_bfd, section, contents, 0, note_size))
1003  error (_("could not get core note contents"));
1004 
1005  descdata = contents;
1006  descend = descdata + note_size;
1007 
1008  if (descdata[note_size - 1] != '\0')
1009  error (_("malformed note - does not end with \\0"));
1010 
1011  count = bfd_get (addr_size_bits, core_bfd, descdata);
1012  descdata += addr_size;
1013 
1014  page_size = bfd_get (addr_size_bits, core_bfd, descdata);
1015  descdata += addr_size;
1016 
1017  if (note_size < 2 * addr_size + count * 3 * addr_size)
1018  error (_("malformed note - too short for supplied file count"));
1019 
1020  printf_filtered (_("Mapped address spaces:\n\n"));
1021  if (gdbarch_addr_bit (gdbarch) == 32)
1022  {
1023  printf_filtered ("\t%10s %10s %10s %10s %s\n",
1024  "Start Addr",
1025  " End Addr",
1026  " Size", " Offset", "objfile");
1027  }
1028  else
1029  {
1030  printf_filtered (" %18s %18s %10s %10s %s\n",
1031  "Start Addr",
1032  " End Addr",
1033  " Size", " Offset", "objfile");
1034  }
1035 
1036  filenames = descdata + count * 3 * addr_size;
1037  while (--count > 0)
1038  {
1039  ULONGEST start, end, file_ofs;
1040 
1041  if (filenames == descend)
1042  error (_("malformed note - filenames end too early"));
1043 
1044  start = bfd_get (addr_size_bits, core_bfd, descdata);
1045  descdata += addr_size;
1046  end = bfd_get (addr_size_bits, core_bfd, descdata);
1047  descdata += addr_size;
1048  file_ofs = bfd_get (addr_size_bits, core_bfd, descdata);
1049  descdata += addr_size;
1050 
1051  file_ofs *= page_size;
1052 
1053  if (gdbarch_addr_bit (gdbarch) == 32)
1054  printf_filtered ("\t%10s %10s %10s %10s %s\n",
1055  paddress (gdbarch, start),
1056  paddress (gdbarch, end),
1057  hex_string (end - start),
1058  hex_string (file_ofs),
1059  filenames);
1060  else
1061  printf_filtered (" %18s %18s %10s %10s %s\n",
1062  paddress (gdbarch, start),
1063  paddress (gdbarch, end),
1064  hex_string (end - start),
1065  hex_string (file_ofs),
1066  filenames);
1067 
1068  filenames += 1 + strlen ((char *) filenames);
1069  }
1070 
1071  do_cleanups (cleanup);
1072 }
1073 
1074 /* Implement "info proc" for a corefile. */
1075 
1076 static void
1077 linux_core_info_proc (struct gdbarch *gdbarch, const char *args,
1078  enum info_proc_what what)
1079 {
1080  int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
1081  int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
1082 
1083  if (exe_f)
1084  {
1085  const char *exe;
1086 
1087  exe = bfd_core_file_failing_command (core_bfd);
1088  if (exe != NULL)
1089  printf_filtered ("exe = '%s'\n", exe);
1090  else
1091  warning (_("unable to find command name in core file"));
1092  }
1093 
1094  if (mappings_f)
1095  linux_core_info_proc_mappings (gdbarch, args);
1096 
1097  if (!exe_f && !mappings_f)
1098  error (_("unable to handle request"));
1099 }
1100 
1102  ULONGEST offset, ULONGEST inode,
1103  int read, int write,
1104  int exec, int modified,
1105  const char *filename,
1106  void *data);
1107 
1108 /* List memory regions in the inferior for a corefile. */
1109 
1110 static int
1113  void *obfd)
1114 {
1115  char mapsfilename[100];
1116  char coredumpfilter_name[100];
1117  char *data, *coredumpfilterdata;
1118  pid_t pid;
1119  /* Default dump behavior of coredump_filter (0x33), according to
1120  Documentation/filesystems/proc.txt from the Linux kernel
1121  tree. */
1126 
1127  /* We need to know the real target PID to access /proc. */
1128  if (current_inferior ()->fake_pid_p)
1129  return 1;
1130 
1131  pid = current_inferior ()->pid;
1132 
1133  if (use_coredump_filter)
1134  {
1135  xsnprintf (coredumpfilter_name, sizeof (coredumpfilter_name),
1136  "/proc/%d/coredump_filter", pid);
1137  coredumpfilterdata = target_fileio_read_stralloc (NULL,
1138  coredumpfilter_name);
1139  if (coredumpfilterdata != NULL)
1140  {
1141  sscanf (coredumpfilterdata, "%x", &filterflags);
1142  xfree (coredumpfilterdata);
1143  }
1144  }
1145 
1146  xsnprintf (mapsfilename, sizeof mapsfilename, "/proc/%d/smaps", pid);
1147  data = target_fileio_read_stralloc (NULL, mapsfilename);
1148  if (data == NULL)
1149  {
1150  /* Older Linux kernels did not support /proc/PID/smaps. */
1151  xsnprintf (mapsfilename, sizeof mapsfilename, "/proc/%d/maps", pid);
1152  data = target_fileio_read_stralloc (NULL, mapsfilename);
1153  }
1154 
1155  if (data != NULL)
1156  {
1157  struct cleanup *cleanup = make_cleanup (xfree, data);
1158  char *line, *t;
1159 
1160  line = strtok_r (data, "\n", &t);
1161  while (line != NULL)
1162  {
1163  ULONGEST addr, endaddr, offset, inode;
1164  const char *permissions, *device, *filename;
1165  struct smaps_vmflags v;
1166  size_t permissions_len, device_len;
1167  int read, write, exec, priv;
1168  int has_anonymous = 0;
1169  int should_dump_p = 0;
1170  int mapping_anon_p;
1171  int mapping_file_p;
1172 
1173  memset (&v, 0, sizeof (v));
1174  read_mapping (line, &addr, &endaddr, &permissions, &permissions_len,
1175  &offset, &device, &device_len, &inode, &filename);
1176  mapping_anon_p = mapping_is_anonymous_p (filename);
1177  /* If the mapping is not anonymous, then we can consider it
1178  to be file-backed. These two states (anonymous or
1179  file-backed) seem to be exclusive, but they can actually
1180  coexist. For example, if a file-backed mapping has
1181  "Anonymous:" pages (see more below), then the Linux
1182  kernel will dump this mapping when the user specified
1183  that she only wants anonymous mappings in the corefile
1184  (*even* when she explicitly disabled the dumping of
1185  file-backed mappings). */
1186  mapping_file_p = !mapping_anon_p;
1187 
1188  /* Decode permissions. */
1189  read = (memchr (permissions, 'r', permissions_len) != 0);
1190  write = (memchr (permissions, 'w', permissions_len) != 0);
1191  exec = (memchr (permissions, 'x', permissions_len) != 0);
1192  /* 'private' here actually means VM_MAYSHARE, and not
1193  VM_SHARED. In order to know if a mapping is really
1194  private or not, we must check the flag "sh" in the
1195  VmFlags field. This is done by decode_vmflags. However,
1196  if we are using a Linux kernel released before the commit
1197  834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1198  not have the VmFlags there. In this case, there is
1199  really no way to know if we are dealing with VM_SHARED,
1200  so we just assume that VM_MAYSHARE is enough. */
1201  priv = memchr (permissions, 'p', permissions_len) != 0;
1202 
1203  /* Try to detect if region should be dumped by parsing smaps
1204  counters. */
1205  for (line = strtok_r (NULL, "\n", &t);
1206  line != NULL && line[0] >= 'A' && line[0] <= 'Z';
1207  line = strtok_r (NULL, "\n", &t))
1208  {
1209  char keyword[64 + 1];
1210 
1211  if (sscanf (line, "%64s", keyword) != 1)
1212  {
1213  warning (_("Error parsing {s,}maps file '%s'"), mapsfilename);
1214  break;
1215  }
1216 
1217  if (strcmp (keyword, "Anonymous:") == 0)
1218  {
1219  /* Older Linux kernels did not support the
1220  "Anonymous:" counter. Check it here. */
1221  has_anonymous = 1;
1222  }
1223  else if (strcmp (keyword, "VmFlags:") == 0)
1224  decode_vmflags (line, &v);
1225 
1226  if (strcmp (keyword, "AnonHugePages:") == 0
1227  || strcmp (keyword, "Anonymous:") == 0)
1228  {
1229  unsigned long number;
1230 
1231  if (sscanf (line, "%*s%lu", &number) != 1)
1232  {
1233  warning (_("Error parsing {s,}maps file '%s' number"),
1234  mapsfilename);
1235  break;
1236  }
1237  if (number > 0)
1238  {
1239  /* Even if we are dealing with a file-backed
1240  mapping, if it contains anonymous pages we
1241  consider it to be *also* an anonymous
1242  mapping, because this is what the Linux
1243  kernel does:
1244 
1245  // Dump segments that have been written to.
1246  if (vma->anon_vma && FILTER(ANON_PRIVATE))
1247  goto whole;
1248 
1249  Note that if the mapping is already marked as
1250  file-backed (i.e., mapping_file_p is
1251  non-zero), then this is a special case, and
1252  this mapping will be dumped either when the
1253  user wants to dump file-backed *or* anonymous
1254  mappings. */
1255  mapping_anon_p = 1;
1256  }
1257  }
1258  }
1259 
1260  if (has_anonymous)
1261  should_dump_p = dump_mapping_p (filterflags, &v, priv,
1262  mapping_anon_p, mapping_file_p,
1263  filename);
1264  else
1265  {
1266  /* Older Linux kernels did not support the "Anonymous:" counter.
1267  If it is missing, we can't be sure - dump all the pages. */
1268  should_dump_p = 1;
1269  }
1270 
1271  /* Invoke the callback function to create the corefile segment. */
1272  if (should_dump_p)
1273  func (addr, endaddr - addr, offset, inode,
1274  read, write, exec, 1, /* MODIFIED is true because we
1275  want to dump the mapping. */
1276  filename, obfd);
1277  }
1278 
1279  do_cleanups (cleanup);
1280  return 0;
1281  }
1282 
1283  return 1;
1284 }
1285 
1286 /* A structure for passing information through
1287  linux_find_memory_regions_full. */
1288 
1290 {
1291  /* The original callback. */
1292 
1294 
1295  /* The original datum. */
1296 
1297  void *obfd;
1298 };
1299 
1300 /* A callback for linux_find_memory_regions that converts between the
1301  "full"-style callback and find_memory_region_ftype. */
1302 
1303 static int
1305  ULONGEST offset, ULONGEST inode,
1306  int read, int write, int exec, int modified,
1307  const char *filename, void *arg)
1308 {
1309  struct linux_find_memory_regions_data *data = arg;
1310 
1311  return data->func (vaddr, size, read, write, exec, modified, data->obfd);
1312 }
1313 
1314 /* A variant of linux_find_memory_regions_full that is suitable as the
1315  gdbarch find_memory_regions method. */
1316 
1317 static int
1320 {
1321  struct linux_find_memory_regions_data data;
1322 
1323  data.func = func;
1324  data.obfd = obfd;
1325 
1326  return linux_find_memory_regions_full (gdbarch,
1328  &data);
1329 }
1330 
1331 /* Determine which signal stopped execution. */
1332 
1333 static int
1334 find_signalled_thread (struct thread_info *info, void *data)
1335 {
1336  if (info->suspend.stop_signal != GDB_SIGNAL_0
1337  && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
1338  return 1;
1339 
1340  return 0;
1341 }
1342 
1343 static enum gdb_signal
1345 {
1346  struct thread_info *info =
1348 
1349  if (info)
1350  return info->suspend.stop_signal;
1351  else
1352  return GDB_SIGNAL_0;
1353 }
1354 
1355 /* Generate corefile notes for SPU contexts. */
1356 
1357 static char *
1358 linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
1359 {
1360  static const char *spu_files[] =
1361  {
1362  "object-id",
1363  "mem",
1364  "regs",
1365  "fpcr",
1366  "lslr",
1367  "decr",
1368  "decr_status",
1369  "signal1",
1370  "signal1_type",
1371  "signal2",
1372  "signal2_type",
1373  "event_mask",
1374  "event_status",
1375  "mbox_info",
1376  "ibox_info",
1377  "wbox_info",
1378  "dma_info",
1379  "proxydma_info",
1380  };
1381 
1382  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
1383  gdb_byte *spu_ids;
1384  LONGEST i, j, size;
1385 
1386  /* Determine list of SPU ids. */
1388  NULL, &spu_ids);
1389 
1390  /* Generate corefile notes for each SPU file. */
1391  for (i = 0; i < size; i += 4)
1392  {
1393  int fd = extract_unsigned_integer (spu_ids + i, 4, byte_order);
1394 
1395  for (j = 0; j < sizeof (spu_files) / sizeof (spu_files[0]); j++)
1396  {
1397  char annex[32], note_name[32];
1398  gdb_byte *spu_data;
1399  LONGEST spu_len;
1400 
1401  xsnprintf (annex, sizeof annex, "%d/%s", fd, spu_files[j]);
1403  annex, &spu_data);
1404  if (spu_len > 0)
1405  {
1406  xsnprintf (note_name, sizeof note_name, "SPU/%s", annex);
1407  note_data = elfcore_write_note (obfd, note_data, note_size,
1408  note_name, NT_SPU,
1409  spu_data, spu_len);
1410  xfree (spu_data);
1411 
1412  if (!note_data)
1413  {
1414  xfree (spu_ids);
1415  return NULL;
1416  }
1417  }
1418  }
1419  }
1420 
1421  if (size > 0)
1422  xfree (spu_ids);
1423 
1424  return note_data;
1425 }
1426 
1427 /* This is used to pass information from
1428  linux_make_mappings_corefile_notes through
1429  linux_find_memory_regions_full. */
1430 
1432 {
1433  /* Number of files mapped. */
1435 
1436  /* The obstack for the main part of the data. */
1437  struct obstack *data_obstack;
1438 
1439  /* The filename obstack. */
1440  struct obstack *filename_obstack;
1441 
1442  /* The architecture's "long" type. */
1443  struct type *long_type;
1444 };
1445 
1447 
1448 /* A callback for linux_find_memory_regions_full that updates the
1449  mappings data for linux_make_mappings_corefile_notes. */
1450 
1451 static int
1453  ULONGEST offset, ULONGEST inode,
1454  int read, int write, int exec, int modified,
1455  const char *filename, void *data)
1456 {
1457  struct linux_make_mappings_data *map_data = data;
1458  gdb_byte buf[sizeof (ULONGEST)];
1459 
1460  if (*filename == '\0' || inode == 0)
1461  return 0;
1462 
1463  ++map_data->file_count;
1464 
1465  pack_long (buf, map_data->long_type, vaddr);
1466  obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1467  pack_long (buf, map_data->long_type, vaddr + size);
1468  obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1469  pack_long (buf, map_data->long_type, offset);
1470  obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
1471 
1472  obstack_grow_str0 (map_data->filename_obstack, filename);
1473 
1474  return 0;
1475 }
1476 
1477 /* Write the file mapping data to the core file, if possible. OBFD is
1478  the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1479  is a pointer to the note size. Returns the new NOTE_DATA and
1480  updates NOTE_SIZE. */
1481 
1482 static char *
1484  char *note_data, int *note_size)
1485 {
1486  struct cleanup *cleanup;
1487  struct obstack data_obstack, filename_obstack;
1488  struct linux_make_mappings_data mapping_data;
1489  struct type *long_type
1490  = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), 0, "long");
1491  gdb_byte buf[sizeof (ULONGEST)];
1492 
1493  obstack_init (&data_obstack);
1494  cleanup = make_cleanup_obstack_free (&data_obstack);
1495  obstack_init (&filename_obstack);
1496  make_cleanup_obstack_free (&filename_obstack);
1497 
1498  mapping_data.file_count = 0;
1499  mapping_data.data_obstack = &data_obstack;
1500  mapping_data.filename_obstack = &filename_obstack;
1501  mapping_data.long_type = long_type;
1502 
1503  /* Reserve space for the count. */
1504  obstack_blank (&data_obstack, TYPE_LENGTH (long_type));
1505  /* We always write the page size as 1 since we have no good way to
1506  determine the correct value. */
1507  pack_long (buf, long_type, 1);
1508  obstack_grow (&data_obstack, buf, TYPE_LENGTH (long_type));
1509 
1511  &mapping_data);
1512 
1513  if (mapping_data.file_count != 0)
1514  {
1515  /* Write the count to the obstack. */
1516  pack_long ((gdb_byte *) obstack_base (&data_obstack),
1517  long_type, mapping_data.file_count);
1518 
1519  /* Copy the filenames to the data obstack. */
1520  obstack_grow (&data_obstack, obstack_base (&filename_obstack),
1521  obstack_object_size (&filename_obstack));
1522 
1523  note_data = elfcore_write_note (obfd, note_data, note_size,
1524  "CORE", NT_FILE,
1525  obstack_base (&data_obstack),
1526  obstack_object_size (&data_obstack));
1527  }
1528 
1529  do_cleanups (cleanup);
1530  return note_data;
1531 }
1532 
1533 /* Structure for passing information from
1534  linux_collect_thread_registers via an iterator to
1535  linux_collect_regset_section_cb. */
1536 
1538 {
1539  struct gdbarch *gdbarch;
1540  const struct regcache *regcache;
1541  bfd *obfd;
1542  char *note_data;
1544  unsigned long lwp;
1545  enum gdb_signal stop_signal;
1547 };
1548 
1549 /* Callback for iterate_over_regset_sections that records a single
1550  regset in the corefile note section. */
1551 
1552 static void
1553 linux_collect_regset_section_cb (const char *sect_name, int size,
1554  const struct regset *regset,
1555  const char *human_name, void *cb_data)
1556 {
1557  char *buf;
1558  struct linux_collect_regset_section_cb_data *data = cb_data;
1559 
1560  if (data->abort_iteration)
1561  return;
1562 
1563  gdb_assert (regset && regset->collect_regset);
1564 
1565  buf = xmalloc (size);
1566  regset->collect_regset (regset, data->regcache, -1, buf, size);
1567 
1568  /* PRSTATUS still needs to be treated specially. */
1569  if (strcmp (sect_name, ".reg") == 0)
1570  data->note_data = (char *) elfcore_write_prstatus
1571  (data->obfd, data->note_data, data->note_size, data->lwp,
1572  gdb_signal_to_host (data->stop_signal), buf);
1573  else
1574  data->note_data = (char *) elfcore_write_register_note
1575  (data->obfd, data->note_data, data->note_size,
1576  sect_name, buf, size);
1577  xfree (buf);
1578 
1579  if (data->note_data == NULL)
1580  data->abort_iteration = 1;
1581 }
1582 
1583 /* Records the thread's register state for the corefile note
1584  section. */
1585 
1586 static char *
1588  ptid_t ptid, bfd *obfd,
1589  char *note_data, int *note_size,
1590  enum gdb_signal stop_signal)
1591 {
1592  struct gdbarch *gdbarch = get_regcache_arch (regcache);
1594 
1595  data.gdbarch = gdbarch;
1596  data.regcache = regcache;
1597  data.obfd = obfd;
1598  data.note_data = note_data;
1599  data.note_size = note_size;
1600  data.stop_signal = stop_signal;
1601  data.abort_iteration = 0;
1602 
1603  /* For remote targets the LWP may not be available, so use the TID. */
1604  data.lwp = ptid_get_lwp (ptid);
1605  if (!data.lwp)
1606  data.lwp = ptid_get_tid (ptid);
1607 
1610  &data, regcache);
1611  return data.note_data;
1612 }
1613 
1614 /* Fetch the siginfo data for the current thread, if it exists. If
1615  there is no data, or we could not read it, return NULL. Otherwise,
1616  return a newly malloc'd buffer holding the data and fill in *SIZE
1617  with the size of the data. The caller is responsible for freeing
1618  the data. */
1619 
1620 static gdb_byte *
1622 {
1623  struct type *siginfo_type;
1624  gdb_byte *buf;
1625  LONGEST bytes_read;
1626  struct cleanup *cleanups;
1627 
1628  if (!gdbarch_get_siginfo_type_p (gdbarch))
1629  return NULL;
1630 
1631  siginfo_type = gdbarch_get_siginfo_type (gdbarch);
1632 
1633  buf = xmalloc (TYPE_LENGTH (siginfo_type));
1634  cleanups = make_cleanup (xfree, buf);
1635 
1637  buf, 0, TYPE_LENGTH (siginfo_type));
1638  if (bytes_read == TYPE_LENGTH (siginfo_type))
1639  {
1640  discard_cleanups (cleanups);
1641  *size = bytes_read;
1642  }
1643  else
1644  {
1645  do_cleanups (cleanups);
1646  buf = NULL;
1647  }
1648 
1649  return buf;
1650 }
1651 
1653 {
1654  struct gdbarch *gdbarch;
1655  int pid;
1656  bfd *obfd;
1657  char *note_data;
1659  enum gdb_signal stop_signal;
1660 };
1661 
1662 /* Called by gdbthread.c once per thread. Records the thread's
1663  register state for the corefile note section. */
1664 
1665 static int
1667 {
1668  struct linux_corefile_thread_data *args = data;
1669 
1670  /* It can be current thread
1671  which cannot be removed by update_thread_list. */
1672  if (info->state == THREAD_EXITED)
1673  return 0;
1674 
1675  if (ptid_get_pid (info->ptid) == args->pid)
1676  {
1677  struct cleanup *old_chain;
1678  struct regcache *regcache;
1679  gdb_byte *siginfo_data;
1680  LONGEST siginfo_size = 0;
1681 
1682  regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
1683 
1684  old_chain = save_inferior_ptid ();
1685  inferior_ptid = info->ptid;
1686  target_fetch_registers (regcache, -1);
1687  siginfo_data = linux_get_siginfo_data (args->gdbarch, &siginfo_size);
1688  do_cleanups (old_chain);
1689 
1690  old_chain = make_cleanup (xfree, siginfo_data);
1691 
1693  (regcache, info->ptid, args->obfd, args->note_data,
1694  args->note_size, args->stop_signal);
1695 
1696  /* Don't return anything if we got no register information above,
1697  such a core file is useless. */
1698  if (args->note_data != NULL)
1699  if (siginfo_data != NULL)
1700  args->note_data = elfcore_write_note (args->obfd,
1701  args->note_data,
1702  args->note_size,
1703  "CORE", NT_SIGINFO,
1704  siginfo_data, siginfo_size);
1705 
1706  do_cleanups (old_chain);
1707  }
1708 
1709  return !args->note_data;
1710 }
1711 
1712 /* Fill the PRPSINFO structure with information about the process being
1713  debugged. Returns 1 in case of success, 0 for failures. Please note that
1714  even if the structure cannot be entirely filled (e.g., GDB was unable to
1715  gather information about the process UID/GID), this function will still
1716  return 1 since some information was already recorded. It will only return
1717  0 iff nothing can be gathered. */
1718 
1719 static int
1720 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo *p)
1721 {
1722  /* The filename which we will use to obtain some info about the process.
1723  We will basically use this to store the `/proc/PID/FILENAME' file. */
1724  char filename[100];
1725  /* The full name of the program which generated the corefile. */
1726  char *fname;
1727  /* The basename of the executable. */
1728  const char *basename;
1729  /* The arguments of the program. */
1730  char *psargs;
1731  char *infargs;
1732  /* The contents of `/proc/PID/stat' and `/proc/PID/status' files. */
1733  char *proc_stat, *proc_status;
1734  /* Temporary buffer. */
1735  char *tmpstr;
1736  /* The valid states of a process, according to the Linux kernel. */
1737  const char valid_states[] = "RSDTZW";
1738  /* The program state. */
1739  const char *prog_state;
1740  /* The state of the process. */
1741  char pr_sname;
1742  /* The PID of the program which generated the corefile. */
1743  pid_t pid;
1744  /* Process flags. */
1745  unsigned int pr_flag;
1746  /* Process nice value. */
1747  long pr_nice;
1748  /* The number of fields read by `sscanf'. */
1749  int n_fields = 0;
1750  /* Cleanups. */
1751  struct cleanup *c;
1752  int i;
1753 
1754  gdb_assert (p != NULL);
1755 
1756  /* Obtaining PID and filename. */
1757  pid = ptid_get_pid (inferior_ptid);
1758  xsnprintf (filename, sizeof (filename), "/proc/%d/cmdline", (int) pid);
1759  fname = target_fileio_read_stralloc (NULL, filename);
1760 
1761  if (fname == NULL || *fname == '\0')
1762  {
1763  /* No program name was read, so we won't be able to retrieve more
1764  information about the process. */
1765  xfree (fname);
1766  return 0;
1767  }
1768 
1769  c = make_cleanup (xfree, fname);
1770  memset (p, 0, sizeof (*p));
1771 
1772  /* Defining the PID. */
1773  p->pr_pid = pid;
1774 
1775  /* Copying the program name. Only the basename matters. */
1776  basename = lbasename (fname);
1777  strncpy (p->pr_fname, basename, sizeof (p->pr_fname));
1778  p->pr_fname[sizeof (p->pr_fname) - 1] = '\0';
1779 
1780  infargs = get_inferior_args ();
1781 
1782  psargs = xstrdup (fname);
1783  if (infargs != NULL)
1784  psargs = reconcat (psargs, psargs, " ", infargs, NULL);
1785 
1786  make_cleanup (xfree, psargs);
1787 
1788  strncpy (p->pr_psargs, psargs, sizeof (p->pr_psargs));
1789  p->pr_psargs[sizeof (p->pr_psargs) - 1] = '\0';
1790 
1791  xsnprintf (filename, sizeof (filename), "/proc/%d/stat", (int) pid);
1792  proc_stat = target_fileio_read_stralloc (NULL, filename);
1793  make_cleanup (xfree, proc_stat);
1794 
1795  if (proc_stat == NULL || *proc_stat == '\0')
1796  {
1797  /* Despite being unable to read more information about the
1798  process, we return 1 here because at least we have its
1799  command line, PID and arguments. */
1800  do_cleanups (c);
1801  return 1;
1802  }
1803 
1804  /* Ok, we have the stats. It's time to do a little parsing of the
1805  contents of the buffer, so that we end up reading what we want.
1806 
1807  The following parsing mechanism is strongly based on the
1808  information generated by the `fs/proc/array.c' file, present in
1809  the Linux kernel tree. More details about how the information is
1810  displayed can be obtained by seeing the manpage of proc(5),
1811  specifically under the entry of `/proc/[pid]/stat'. */
1812 
1813  /* Getting rid of the PID, since we already have it. */
1814  while (isdigit (*proc_stat))
1815  ++proc_stat;
1816 
1817  proc_stat = skip_spaces (proc_stat);
1818 
1819  /* ps command also relies on no trailing fields ever contain ')'. */
1820  proc_stat = strrchr (proc_stat, ')');
1821  if (proc_stat == NULL)
1822  {
1823  do_cleanups (c);
1824  return 1;
1825  }
1826  proc_stat++;
1827 
1828  proc_stat = skip_spaces (proc_stat);
1829 
1830  n_fields = sscanf (proc_stat,
1831  "%c" /* Process state. */
1832  "%d%d%d" /* Parent PID, group ID, session ID. */
1833  "%*d%*d" /* tty_nr, tpgid (not used). */
1834  "%u" /* Flags. */
1835  "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1836  cmajflt (not used). */
1837  "%*s%*s%*s%*s" /* utime, stime, cutime,
1838  cstime (not used). */
1839  "%*s" /* Priority (not used). */
1840  "%ld", /* Nice. */
1841  &pr_sname,
1842  &p->pr_ppid, &p->pr_pgrp, &p->pr_sid,
1843  &pr_flag,
1844  &pr_nice);
1845 
1846  if (n_fields != 6)
1847  {
1848  /* Again, we couldn't read the complementary information about
1849  the process state. However, we already have minimal
1850  information, so we just return 1 here. */
1851  do_cleanups (c);
1852  return 1;
1853  }
1854 
1855  /* Filling the structure fields. */
1856  prog_state = strchr (valid_states, pr_sname);
1857  if (prog_state != NULL)
1858  p->pr_state = prog_state - valid_states;
1859  else
1860  {
1861  /* Zero means "Running". */
1862  p->pr_state = 0;
1863  }
1864 
1865  p->pr_sname = p->pr_state > 5 ? '.' : pr_sname;
1866  p->pr_zomb = p->pr_sname == 'Z';
1867  p->pr_nice = pr_nice;
1868  p->pr_flag = pr_flag;
1869 
1870  /* Finally, obtaining the UID and GID. For that, we read and parse the
1871  contents of the `/proc/PID/status' file. */
1872  xsnprintf (filename, sizeof (filename), "/proc/%d/status", (int) pid);
1873  proc_status = target_fileio_read_stralloc (NULL, filename);
1874  make_cleanup (xfree, proc_status);
1875 
1876  if (proc_status == NULL || *proc_status == '\0')
1877  {
1878  /* Returning 1 since we already have a bunch of information. */
1879  do_cleanups (c);
1880  return 1;
1881  }
1882 
1883  /* Extracting the UID. */
1884  tmpstr = strstr (proc_status, "Uid:");
1885  if (tmpstr != NULL)
1886  {
1887  /* Advancing the pointer to the beginning of the UID. */
1888  tmpstr += sizeof ("Uid:");
1889  while (*tmpstr != '\0' && !isdigit (*tmpstr))
1890  ++tmpstr;
1891 
1892  if (isdigit (*tmpstr))
1893  p->pr_uid = strtol (tmpstr, &tmpstr, 10);
1894  }
1895 
1896  /* Extracting the GID. */
1897  tmpstr = strstr (proc_status, "Gid:");
1898  if (tmpstr != NULL)
1899  {
1900  /* Advancing the pointer to the beginning of the GID. */
1901  tmpstr += sizeof ("Gid:");
1902  while (*tmpstr != '\0' && !isdigit (*tmpstr))
1903  ++tmpstr;
1904 
1905  if (isdigit (*tmpstr))
1906  p->pr_gid = strtol (tmpstr, &tmpstr, 10);
1907  }
1908 
1909  do_cleanups (c);
1910 
1911  return 1;
1912 }
1913 
1914 /* Build the note section for a corefile, and return it in a malloc
1915  buffer. */
1916 
1917 static char *
1918 linux_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
1919 {
1920  struct linux_corefile_thread_data thread_args;
1921  struct elf_internal_linux_prpsinfo prpsinfo;
1922  char *note_data = NULL;
1923  gdb_byte *auxv;
1924  int auxv_len;
1925 
1927  return NULL;
1928 
1929  if (linux_fill_prpsinfo (&prpsinfo))
1930  {
1932  {
1933  note_data = gdbarch_elfcore_write_linux_prpsinfo (gdbarch, obfd,
1934  note_data, note_size,
1935  &prpsinfo);
1936  }
1937  else
1938  {
1939  if (gdbarch_ptr_bit (gdbarch) == 64)
1940  note_data = elfcore_write_linux_prpsinfo64 (obfd,
1941  note_data, note_size,
1942  &prpsinfo);
1943  else
1944  note_data = elfcore_write_linux_prpsinfo32 (obfd,
1945  note_data, note_size,
1946  &prpsinfo);
1947  }
1948  }
1949 
1950  /* Thread register information. */
1951  TRY
1952  {
1953  update_thread_list ();
1954  }
1956  {
1958  }
1959  END_CATCH
1960 
1961  thread_args.gdbarch = gdbarch;
1962  thread_args.pid = ptid_get_pid (inferior_ptid);
1963  thread_args.obfd = obfd;
1964  thread_args.note_data = note_data;
1965  thread_args.note_size = note_size;
1966  thread_args.stop_signal = find_stop_signal ();
1968  note_data = thread_args.note_data;
1969  if (!note_data)
1970  return NULL;
1971 
1972  /* Auxillary vector. */
1974  NULL, &auxv);
1975  if (auxv_len > 0)
1976  {
1977  note_data = elfcore_write_note (obfd, note_data, note_size,
1978  "CORE", NT_AUXV, auxv, auxv_len);
1979  xfree (auxv);
1980 
1981  if (!note_data)
1982  return NULL;
1983  }
1984 
1985  /* SPU information. */
1986  note_data = linux_spu_make_corefile_notes (obfd, note_data, note_size);
1987  if (!note_data)
1988  return NULL;
1989 
1990  /* File mappings. */
1991  note_data = linux_make_mappings_corefile_notes (gdbarch, obfd,
1992  note_data, note_size);
1993 
1994  return note_data;
1995 }
1996 
1997 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
1998  gdbarch.h. This function is not static because it is exported to
1999  other -tdep files. */
2000 
2001 enum gdb_signal
2003 {
2004  switch (signal)
2005  {
2006  case 0:
2007  return GDB_SIGNAL_0;
2008 
2009  case LINUX_SIGHUP:
2010  return GDB_SIGNAL_HUP;
2011 
2012  case LINUX_SIGINT:
2013  return GDB_SIGNAL_INT;
2014 
2015  case LINUX_SIGQUIT:
2016  return GDB_SIGNAL_QUIT;
2017 
2018  case LINUX_SIGILL:
2019  return GDB_SIGNAL_ILL;
2020 
2021  case LINUX_SIGTRAP:
2022  return GDB_SIGNAL_TRAP;
2023 
2024  case LINUX_SIGABRT:
2025  return GDB_SIGNAL_ABRT;
2026 
2027  case LINUX_SIGBUS:
2028  return GDB_SIGNAL_BUS;
2029 
2030  case LINUX_SIGFPE:
2031  return GDB_SIGNAL_FPE;
2032 
2033  case LINUX_SIGKILL:
2034  return GDB_SIGNAL_KILL;
2035 
2036  case LINUX_SIGUSR1:
2037  return GDB_SIGNAL_USR1;
2038 
2039  case LINUX_SIGSEGV:
2040  return GDB_SIGNAL_SEGV;
2041 
2042  case LINUX_SIGUSR2:
2043  return GDB_SIGNAL_USR2;
2044 
2045  case LINUX_SIGPIPE:
2046  return GDB_SIGNAL_PIPE;
2047 
2048  case LINUX_SIGALRM:
2049  return GDB_SIGNAL_ALRM;
2050 
2051  case LINUX_SIGTERM:
2052  return GDB_SIGNAL_TERM;
2053 
2054  case LINUX_SIGCHLD:
2055  return GDB_SIGNAL_CHLD;
2056 
2057  case LINUX_SIGCONT:
2058  return GDB_SIGNAL_CONT;
2059 
2060  case LINUX_SIGSTOP:
2061  return GDB_SIGNAL_STOP;
2062 
2063  case LINUX_SIGTSTP:
2064  return GDB_SIGNAL_TSTP;
2065 
2066  case LINUX_SIGTTIN:
2067  return GDB_SIGNAL_TTIN;
2068 
2069  case LINUX_SIGTTOU:
2070  return GDB_SIGNAL_TTOU;
2071 
2072  case LINUX_SIGURG:
2073  return GDB_SIGNAL_URG;
2074 
2075  case LINUX_SIGXCPU:
2076  return GDB_SIGNAL_XCPU;
2077 
2078  case LINUX_SIGXFSZ:
2079  return GDB_SIGNAL_XFSZ;
2080 
2081  case LINUX_SIGVTALRM:
2082  return GDB_SIGNAL_VTALRM;
2083 
2084  case LINUX_SIGPROF:
2085  return GDB_SIGNAL_PROF;
2086 
2087  case LINUX_SIGWINCH:
2088  return GDB_SIGNAL_WINCH;
2089 
2090  /* No way to differentiate between SIGIO and SIGPOLL.
2091  Therefore, we just handle the first one. */
2092  case LINUX_SIGIO:
2093  return GDB_SIGNAL_IO;
2094 
2095  case LINUX_SIGPWR:
2096  return GDB_SIGNAL_PWR;
2097 
2098  case LINUX_SIGSYS:
2099  return GDB_SIGNAL_SYS;
2100 
2101  /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2102  therefore we have to handle them here. */
2103  case LINUX_SIGRTMIN:
2104  return GDB_SIGNAL_REALTIME_32;
2105 
2106  case LINUX_SIGRTMAX:
2107  return GDB_SIGNAL_REALTIME_64;
2108  }
2109 
2110  if (signal >= LINUX_SIGRTMIN + 1 && signal <= LINUX_SIGRTMAX - 1)
2111  {
2112  int offset = signal - LINUX_SIGRTMIN + 1;
2113 
2114  return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_33 + offset);
2115  }
2116 
2117  return GDB_SIGNAL_UNKNOWN;
2118 }
2119 
2120 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2121  gdbarch.h. This function is not static because it is exported to
2122  other -tdep files. */
2123 
2124 int
2126  enum gdb_signal signal)
2127 {
2128  switch (signal)
2129  {
2130  case GDB_SIGNAL_0:
2131  return 0;
2132 
2133  case GDB_SIGNAL_HUP:
2134  return LINUX_SIGHUP;
2135 
2136  case GDB_SIGNAL_INT:
2137  return LINUX_SIGINT;
2138 
2139  case GDB_SIGNAL_QUIT:
2140  return LINUX_SIGQUIT;
2141 
2142  case GDB_SIGNAL_ILL:
2143  return LINUX_SIGILL;
2144 
2145  case GDB_SIGNAL_TRAP:
2146  return LINUX_SIGTRAP;
2147 
2148  case GDB_SIGNAL_ABRT:
2149  return LINUX_SIGABRT;
2150 
2151  case GDB_SIGNAL_FPE:
2152  return LINUX_SIGFPE;
2153 
2154  case GDB_SIGNAL_KILL:
2155  return LINUX_SIGKILL;
2156 
2157  case GDB_SIGNAL_BUS:
2158  return LINUX_SIGBUS;
2159 
2160  case GDB_SIGNAL_SEGV:
2161  return LINUX_SIGSEGV;
2162 
2163  case GDB_SIGNAL_SYS:
2164  return LINUX_SIGSYS;
2165 
2166  case GDB_SIGNAL_PIPE:
2167  return LINUX_SIGPIPE;
2168 
2169  case GDB_SIGNAL_ALRM:
2170  return LINUX_SIGALRM;
2171 
2172  case GDB_SIGNAL_TERM:
2173  return LINUX_SIGTERM;
2174 
2175  case GDB_SIGNAL_URG:
2176  return LINUX_SIGURG;
2177 
2178  case GDB_SIGNAL_STOP:
2179  return LINUX_SIGSTOP;
2180 
2181  case GDB_SIGNAL_TSTP:
2182  return LINUX_SIGTSTP;
2183 
2184  case GDB_SIGNAL_CONT:
2185  return LINUX_SIGCONT;
2186 
2187  case GDB_SIGNAL_CHLD:
2188  return LINUX_SIGCHLD;
2189 
2190  case GDB_SIGNAL_TTIN:
2191  return LINUX_SIGTTIN;
2192 
2193  case GDB_SIGNAL_TTOU:
2194  return LINUX_SIGTTOU;
2195 
2196  case GDB_SIGNAL_IO:
2197  return LINUX_SIGIO;
2198 
2199  case GDB_SIGNAL_XCPU:
2200  return LINUX_SIGXCPU;
2201 
2202  case GDB_SIGNAL_XFSZ:
2203  return LINUX_SIGXFSZ;
2204 
2205  case GDB_SIGNAL_VTALRM:
2206  return LINUX_SIGVTALRM;
2207 
2208  case GDB_SIGNAL_PROF:
2209  return LINUX_SIGPROF;
2210 
2211  case GDB_SIGNAL_WINCH:
2212  return LINUX_SIGWINCH;
2213 
2214  case GDB_SIGNAL_USR1:
2215  return LINUX_SIGUSR1;
2216 
2217  case GDB_SIGNAL_USR2:
2218  return LINUX_SIGUSR2;
2219 
2220  case GDB_SIGNAL_PWR:
2221  return LINUX_SIGPWR;
2222 
2223  case GDB_SIGNAL_POLL:
2224  return LINUX_SIGPOLL;
2225 
2226  /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2227  therefore we have to handle it here. */
2228  case GDB_SIGNAL_REALTIME_32:
2229  return LINUX_SIGRTMIN;
2230 
2231  /* Same comment applies to _64. */
2232  case GDB_SIGNAL_REALTIME_64:
2233  return LINUX_SIGRTMAX;
2234  }
2235 
2236  /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2237  if (signal >= GDB_SIGNAL_REALTIME_33
2238  && signal <= GDB_SIGNAL_REALTIME_63)
2239  {
2240  int offset = signal - GDB_SIGNAL_REALTIME_33;
2241 
2242  return LINUX_SIGRTMIN + 1 + offset;
2243  }
2244 
2245  return -1;
2246 }
2247 
2248 /* Rummage through mappings to find a mapping's size. */
2249 
2250 static int
2251 find_mapping_size (CORE_ADDR vaddr, unsigned long size,
2252  int read, int write, int exec, int modified,
2253  void *data)
2254 {
2255  struct mem_range *range = data;
2256 
2257  if (vaddr == range->start)
2258  {
2259  range->length = size;
2260  return 1;
2261  }
2262  return 0;
2263 }
2264 
2265 /* Helper for linux_vsyscall_range that does the real work of finding
2266  the vsyscall's address range. */
2267 
2268 static int
2270 {
2271  if (target_auxv_search (&current_target, AT_SYSINFO_EHDR, &range->start) <= 0)
2272  return 0;
2273 
2274  /* This is installed by linux_init_abi below, so should always be
2275  available. */
2277 
2278  range->length = 0;
2280  return 1;
2281 }
2282 
2283 /* Implementation of the "vsyscall_range" gdbarch hook. Handles
2284  caching, and defers the real work to linux_vsyscall_range_raw. */
2285 
2286 static int
2288 {
2289  struct linux_info *info = get_linux_inferior_data ();
2290 
2291  if (info->vsyscall_range_p == 0)
2292  {
2293  if (linux_vsyscall_range_raw (gdbarch, &info->vsyscall_range))
2294  info->vsyscall_range_p = 1;
2295  else
2296  info->vsyscall_range_p = -1;
2297  }
2298 
2299  if (info->vsyscall_range_p < 0)
2300  return 0;
2301 
2302  *range = info->vsyscall_range;
2303  return 1;
2304 }
2305 
2306 /* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2307  definitions would be dependent on compilation host. */
2308 #define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2309 #define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2310 
2311 /* See gdbarch.sh 'infcall_mmap'. */
2312 
2313 static CORE_ADDR
2315 {
2316  struct objfile *objf;
2317  /* Do there still exist any Linux systems without "mmap64"?
2318  "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2319  struct value *mmap_val = find_function_in_inferior ("mmap64", &objf);
2320  struct value *addr_val;
2321  struct gdbarch *gdbarch = get_objfile_arch (objf);
2322  CORE_ADDR retval;
2323  enum
2324  {
2325  ARG_ADDR, ARG_LENGTH, ARG_PROT, ARG_FLAGS, ARG_FD, ARG_OFFSET, ARG_LAST
2326  };
2327  struct value *arg[ARG_LAST];
2328 
2329  arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2330  0);
2331  /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2332  arg[ARG_LENGTH] = value_from_ulongest
2333  (builtin_type (gdbarch)->builtin_unsigned_long, size);
2335  | GDB_MMAP_PROT_EXEC))
2336  == 0);
2337  arg[ARG_PROT] = value_from_longest (builtin_type (gdbarch)->builtin_int, prot);
2338  arg[ARG_FLAGS] = value_from_longest (builtin_type (gdbarch)->builtin_int,
2341  arg[ARG_FD] = value_from_longest (builtin_type (gdbarch)->builtin_int, -1);
2342  arg[ARG_OFFSET] = value_from_longest (builtin_type (gdbarch)->builtin_int64,
2343  0);
2344  addr_val = call_function_by_hand (mmap_val, ARG_LAST, arg);
2345  retval = value_as_address (addr_val);
2346  if (retval == (CORE_ADDR) -1)
2347  error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2348  pulongest (size));
2349  return retval;
2350 }
2351 
2352 /* See gdbarch.sh 'infcall_munmap'. */
2353 
2354 static void
2356 {
2357  struct objfile *objf;
2358  struct value *munmap_val = find_function_in_inferior ("munmap", &objf);
2359  struct value *retval_val;
2360  struct gdbarch *gdbarch = get_objfile_arch (objf);
2361  LONGEST retval;
2362  enum
2363  {
2364  ARG_ADDR, ARG_LENGTH, ARG_LAST
2365  };
2366  struct value *arg[ARG_LAST];
2367 
2368  arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2369  addr);
2370  /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2371  arg[ARG_LENGTH] = value_from_ulongest
2372  (builtin_type (gdbarch)->builtin_unsigned_long, size);
2373  retval_val = call_function_by_hand (munmap_val, ARG_LAST, arg);
2374  retval = value_as_long (retval_val);
2375  if (retval != 0)
2376  warning (_("Failed inferior munmap call at %s for %s bytes, "
2377  "errno is changed."),
2378  hex_string (addr), pulongest (size));
2379 }
2380 
2381 /* See linux-tdep.h. */
2382 
2383 CORE_ADDR
2385 {
2386  CORE_ADDR addr;
2387  int bp_len;
2388 
2389  /* Determine entry point from target auxiliary vector. This avoids
2390  the need for symbols. Also, when debugging a stand-alone SPU
2391  executable, entry_point_address () will point to an SPU
2392  local-store address and is thus not usable as displaced stepping
2393  location. The auxiliary vector gets us the PowerPC-side entry
2394  point address instead. */
2395  if (target_auxv_search (&current_target, AT_ENTRY, &addr) <= 0)
2396  error (_("Cannot find AT_ENTRY auxiliary vector entry."));
2397 
2398  /* Make certain that the address points at real code, and not a
2399  function descriptor. */
2400  addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
2401  &current_target);
2402 
2403  /* Inferior calls also use the entry point as a breakpoint location.
2404  We don't want displaced stepping to interfere with those
2405  breakpoints, so leave space. */
2406  gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
2407  addr += bp_len * 2;
2408 
2409  return addr;
2410 }
2411 
2412 /* Display whether the gcore command is using the
2413  /proc/PID/coredump_filter file. */
2414 
2415 static void
2416 show_use_coredump_filter (struct ui_file *file, int from_tty,
2417  struct cmd_list_element *c, const char *value)
2418 {
2419  fprintf_filtered (file, _("Use of /proc/PID/coredump_filter file to generate"
2420  " corefiles is %s.\n"), value);
2421 }
2422 
2423 /* To be called from the various GDB_OSABI_LINUX handlers for the
2424  various GNU/Linux architectures and machine types. */
2425 
2426 void
2428 {
2444 }
2445 
2446 /* Provide a prototype to silence -Wmissing-prototypes. */
2448 
2449 void
2451 {
2452  linux_gdbarch_data_handle =
2454 
2455  /* Set a cache per-inferior. */
2457  = register_inferior_data_with_cleanup (NULL, linux_inferior_data_cleanup);
2458  /* Observers used to invalidate the cache when needed. */
2461 
2462  add_setshow_boolean_cmd ("use-coredump-filter", class_files,
2463  &use_coredump_filter, _("\
2464 Set whether gcore should consider /proc/PID/coredump_filter."),
2465  _("\
2466 Show whether gcore should consider /proc/PID/coredump_filter."),
2467  _("\
2468 Use this command to set whether gcore should consider the contents\n\
2469 of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2470 about this file, refer to the manpage of core(5)."),
2472  &setlist, &showlist);
2473 }
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
ssize_t read(int fd, void *buf, size_t count)
Definition: expect-read1.c:26
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
static void show_use_coredump_filter(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: linux-tdep.c:2416
struct value * call_function_by_hand(struct value *function, int nargs, struct value **args)
Definition: infcall.c:488
unsigned int exclude_coredump
Definition: linux-tdep.c:81
static void * init_linux_gdbarch_data(struct gdbarch *gdbarch)
Definition: linux-tdep.c:166
int linux_is_uclinux(void)
Definition: linux-tdep.c:368
void set_gdbarch_core_pid_to_str(struct gdbarch *gdbarch, gdbarch_core_pid_to_str_ftype core_pid_to_str)
Definition: gdbarch.c:3542
int vsyscall_range_p
Definition: linux-tdep.c:195
void set_gdbarch_gdb_signal_to_target(struct gdbarch *gdbarch, gdbarch_gdb_signal_to_target_ftype gdb_signal_to_target)
Definition: gdbarch.c:3953
bfd_vma CORE_ADDR
Definition: common-types.h:41
static int linux_vsyscall_range_raw(struct gdbarch *gdbarch, struct mem_range *range)
Definition: linux-tdep.c:2269
static linux_find_memory_region_ftype linux_make_mappings_callback
Definition: linux-tdep.c:1446
void xfree(void *)
Definition: common-utils.c:97
char * get_inferior_args(void)
Definition: infcmd.c:187
void set_gdbarch_infcall_mmap(struct gdbarch *gdbarch, gdbarch_infcall_mmap_ftype infcall_mmap)
Definition: gdbarch.c:4682
char * target_fileio_readlink(struct inferior *inf, const char *filename, int *target_errno)
Definition: target.c:2964
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
LONGEST value_as_long(struct value *val)
Definition: value.c:2654
void(* func)(char *)
int gdbarch_int_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1490
if(!(yy_init))
Definition: ada-lex.c:1072
struct gdbarch * gdbarch
Definition: linux-tdep.c:1654
void warning(const char *fmt,...)
Definition: errors.c:26
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1227
void set_gdbarch_get_siginfo_type(struct gdbarch *gdbarch, gdbarch_get_siginfo_type_ftype get_siginfo_type)
Definition: gdbarch.c:3977
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1690
static void linux_core_info_proc_mappings(struct gdbarch *gdbarch, const char *args)
Definition: linux-tdep.c:974
LONGEST target_read_alloc(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte **buf_p)
Definition: target.c:1971
void * gdbarch_data(struct gdbarch *gdbarch, struct gdbarch_data *data)
Definition: gdbarch.c:4845
static int linux_vsyscall_range(struct gdbarch *gdbarch, struct mem_range *range)
Definition: linux-tdep.c:2287
int pid
Definition: inferior.h:299
#define GDB_MMAP_MAP_PRIVATE
Definition: linux-tdep.c:2308
void set_gdbarch_gdb_signal_from_target(struct gdbarch *gdbarch, gdbarch_gdb_signal_from_target_ftype gdb_signal_from_target)
Definition: gdbarch.c:3929
void linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: linux-tdep.c:2427
static void linux_core_info_proc(struct gdbarch *gdbarch, const char *args, enum info_proc_what what)
Definition: linux-tdep.c:1077
void set_gdbarch_find_memory_regions(struct gdbarch *gdbarch, gdbarch_find_memory_regions_ftype find_memory_regions)
Definition: gdbarch.c:3470
static int find_mapping_size(CORE_ADDR vaddr, unsigned long size, int read, int write, int exec, int modified, void *data)
Definition: linux-tdep.c:2251
int gdbarch_long_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1507
struct type * arch_composite_type(struct gdbarch *gdbarch, char *name, enum type_code code)
Definition: gdbtypes.c:4682
struct observer * observer_attach_inferior_exit(observer_inferior_exit_ftype *f)
void append_composite_type_field_aligned(struct type *t, char *name, struct type *field, int alignment)
Definition: gdbtypes.c:4717
void target_fetch_registers(struct regcache *regcache, int regno)
Definition: target.c:3419
char * skip_spaces(char *chp)
Definition: common-utils.c:259
struct obstack * filename_obstack
Definition: linux-tdep.c:1440
#define _(String)
Definition: gdb_locale.h:40
enum gdb_signal stop_signal
Definition: gdbthread.h:159
unsigned int uses_huge_tlb
Definition: linux-tdep.c:77
static char * linux_core_pid_to_str(struct gdbarch *gdbarch, ptid_t ptid)
Definition: linux-tdep.c:385
#define END_CATCH
static void linux_infcall_munmap(CORE_ADDR addr, CORE_ADDR size)
Definition: linux-tdep.c:2355
void printf_filtered(const char *format,...)
Definition: utils.c:2388
#define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE)
Definition: gdbarch.h:1615
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
Definition: ptid.h:35
static char * linux_make_mappings_corefile_notes(struct gdbarch *gdbarch, bfd *obfd, char *note_data, int *note_size)
Definition: linux-tdep.c:1483
find_memory_region_ftype func
Definition: linux-tdep.c:1293
static int linux_has_shared_address_space(struct gdbarch *gdbarch)
Definition: linux-tdep.c:377
static gdb_byte * linux_get_siginfo_data(struct gdbarch *gdbarch, LONGEST *size)
Definition: linux-tdep.c:1621
static void invalidate_linux_cache_inf(struct inferior *inf)
Definition: linux-tdep.c:202
struct type * long_type
Definition: linux-tdep.c:1443
Definition: regset.h:34
void null_cleanup(void *arg)
Definition: cleanups.c:295
#define TRY
static struct linux_gdbarch_data * get_linux_gdbarch_data(struct gdbarch *gdbarch)
Definition: linux-tdep.c:172
static char * linux_make_corefile_notes(struct gdbarch *gdbarch, bfd *obfd, int *note_size)
Definition: linux-tdep.c:1918
struct thread_info * iterate_over_threads(thread_callback_func, void *)
Definition: thread.c:419
initialize_file_ftype _initialize_linux_tdep
#define GDB_MMAP_MAP_ANONYMOUS
Definition: linux-tdep.c:2309
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
static int mapping_is_anonymous_p(const char *filename)
Definition: linux-tdep.c:481
struct cleanup * save_inferior_ptid(void)
Definition: infrun.c:7538
unsigned int initialized_p
Definition: linux-tdep.c:69
int gdbarch_find_memory_regions(struct gdbarch *gdbarch, find_memory_region_ftype func, void *data)
Definition: gdbarch.c:3460
int gdbarch_iterate_over_regset_sections_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3381
#define CATCH(EXCEPTION, MASK)
struct target_ops current_target
enum gdb_signal linux_gdb_signal_from_target(struct gdbarch *gdbarch, int signal)
Definition: linux-tdep.c:2002
void initialize_file_ftype(void)
Definition: defs.h:281
static CORE_ADDR linux_infcall_mmap(CORE_ADDR size, unsigned prot)
Definition: linux-tdep.c:2314
int gdbarch_find_memory_regions_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3453
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
struct value * find_function_in_inferior(const char *name, struct objfile **objf_p)
Definition: valops.c:128
static const struct inferior_data * linux_inferior_data
Definition: linux-tdep.c:178
const char * skip_spaces_const(const char *chp)
Definition: common-utils.c:271
Definition: defs.h:452
struct cleanup * compile_rx_or_error(regex_t *pattern, const char *rx, const char *message)
Definition: utils.c:1163
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition: gdbarch.c:2975
Definition: defs.h:449
void set_gdbarch_infcall_munmap(struct gdbarch *gdbarch, gdbarch_infcall_munmap_ftype infcall_munmap)
Definition: gdbarch.c:4699
int gdbarch_elfcore_write_linux_prpsinfo_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3429
int target_auxv_search(struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
Definition: auxv.c:375
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
void exception_print(struct ui_file *file, struct gdb_exception e)
Definition: exceptions.c:109
void puts_filtered(const char *string)
Definition: utils.c:2428
static struct type * linux_get_siginfo_type(struct gdbarch *gdbarch)
Definition: linux-tdep.c:247
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
static void linux_inferior_data_cleanup(struct inferior *inf, void *arg)
Definition: linux-tdep.c:219
Definition: gdbtypes.h:749
int gdb_signal_to_host(enum gdb_signal)
Definition: signals.c:631
struct type * init_vector_type(struct type *elt_type, int n)
Definition: gdbtypes.c:1229
#define TYPE_TARGET_STUB(t)
Definition: gdbtypes.h:253
#define GDB_MMAP_PROT_READ
Definition: arch-utils.h:198
Definition: gnu-nat.c:163
static const char * type
Definition: language.c:103
#define gdb_assert(expr)
Definition: gdb_assert.h:33
#define GDB_MMAP_PROT_WRITE
Definition: arch-utils.h:199
static void linux_info_proc(struct gdbarch *gdbarch, const char *args, enum info_proc_what what)
Definition: linux-tdep.c:681
struct value * value_from_longest(struct type *type, LONGEST num)
Definition: value.c:3464
unsigned dummy
Definition: go32-nat.c:1071
struct mem_range vsyscall_range
Definition: linux-tdep.c:190
static void decode_vmflags(char *p, struct smaps_vmflags *v)
Definition: linux-tdep.c:446
static int dump_mapping_p(enum filterflags filterflags, const struct smaps_vmflags *v, int maybe_private_p, int mapping_anon_p, int mapping_file_p, const char *filename)
Definition: linux-tdep.c:601
static int linux_find_memory_regions(struct gdbarch *gdbarch, find_memory_region_ftype func, void *obfd)
Definition: linux-tdep.c:1318
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1707
void set_gdbarch_make_corefile_notes(struct gdbarch *gdbarch, gdbarch_make_corefile_notes_ftype make_corefile_notes)
Definition: gdbarch.c:3422
struct obstack * data_obstack
Definition: linux-tdep.c:1437
#define target_has_execution
Definition: target.h:1726
Definition: value.c:65
static void linux_collect_regset_section_cb(const char *sect_name, int size, const struct regset *regset, const char *human_name, void *cb_data)
Definition: linux-tdep.c:1553
ULONGEST strtoulst(const char *num, const char **trailer, int base)
Definition: common-utils.c:188
#define GDB_MMAP_PROT_EXEC
Definition: arch-utils.h:200
static enum gdb_signal find_stop_signal(void)
Definition: linux-tdep.c:1344
struct type * arch_integer_type(struct gdbarch *gdbarch, int bit, int unsigned_p, char *name)
Definition: gdbtypes.c:4552
info_proc_what
Definition: defs.h:431
void set_gdbarch_has_shared_address_space(struct gdbarch *gdbarch, gdbarch_has_shared_address_space_ftype has_shared_address_space)
Definition: gdbarch.c:4390
static int linux_fill_prpsinfo(struct elf_internal_linux_prpsinfo *p)
Definition: linux-tdep.c:1720
static char * linux_collect_thread_registers(const struct regcache *regcache, ptid_t ptid, bfd *obfd, char *note_data, int *note_size, enum gdb_signal stop_signal)
Definition: linux-tdep.c:1587
char * target_fileio_read_stralloc(struct inferior *inf, const char *filename)
Definition: target.c:3079
struct observer * observer_attach_inferior_appeared(observer_inferior_appeared_ftype *f)
int linux_find_memory_region_ftype(ULONGEST vaddr, ULONGEST size, ULONGEST offset, ULONGEST inode, int read, int write, int exec, int modified, const char *filename, void *data)
Definition: linux-tdep.c:1101
void * xmalloc(YYSIZE_T)
CORE_ADDR linux_displaced_step_location(struct gdbarch *gdbarch)
Definition: linux-tdep.c:2384
char * normal_pid_to_str(ptid_t ptid)
Definition: target.c:3207
static int find_signalled_thread(struct thread_info *info, void *data)
Definition: linux-tdep.c:1334
Definition: value.c:172
int ptid_get_pid(ptid_t ptid)
Definition: ptid.c:52
static char * linux_spu_make_corefile_notes(bfd *obfd, char *note_data, int *note_size)
Definition: linux-tdep.c:1358
static void read_mapping(const char *line, ULONGEST *addr, ULONGEST *endaddr, const char **permissions, size_t *permissions_len, ULONGEST *offset, const char **device, size_t *device_len, ULONGEST *inode, const char **filename)
Definition: linux-tdep.c:401
void set_gdbarch_core_info_proc(struct gdbarch *gdbarch, gdbarch_core_info_proc_ftype core_info_proc)
Definition: gdbarch.c:4539
#define gdb_static_assert(expr)
Definition: gdb_assert.h:25
const char const char int
Definition: command.h:229
bfd_byte gdb_byte
Definition: common-types.h:38
struct gdbarch * gdbarch_from_bfd(bfd *abfd)
Definition: arch-utils.c:560
void append_composite_type_field(struct type *t, char *name, struct type *field)
Definition: gdbtypes.c:4757
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
Definition: value.c:3490
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
long ptid_get_tid(ptid_t ptid)
Definition: ptid.c:68
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
static int linux_find_memory_regions_thunk(ULONGEST vaddr, ULONGEST size, ULONGEST offset, ULONGEST inode, int read, int write, int exec, int modified, const char *filename, void *arg)
Definition: linux-tdep.c:1304
int linux_gdb_signal_to_target(struct gdbarch *gdbarch, enum gdb_signal signal)
Definition: linux-tdep.c:2125
char * gdbarch_elfcore_write_linux_prpsinfo(struct gdbarch *gdbarch, bfd *obfd, char *note_data, int *note_size, const struct elf_internal_linux_prpsinfo *info)
Definition: gdbarch.c:3436
filterflags
Definition: linux-tdep.c:49
void update_thread_list(void)
Definition: thread.c:1735
Definition: defs.h:443
ptid_t ptid
Definition: gdbthread.h:169
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
struct type * siginfo_type
Definition: linux-tdep.c:162
void set_gdbarch_info_proc(struct gdbarch *gdbarch, gdbarch_info_proc_ftype info_proc)
Definition: gdbarch.c:4515
const gdb_byte * gdbarch_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
Definition: gdbarch.c:2662
int gdbarch_get_siginfo_type_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3960
enum gdb_signal stop_signal
Definition: linux-tdep.c:1659
struct ui_file * gdb_stderr
Definition: main.c:72
ptid_t inferior_ptid
Definition: infcmd.c:124
const struct regcache * regcache
Definition: linux-tdep.c:1540
int offset
Definition: agent.c:65
int line
Definition: symtab.h:1570
struct thread_suspend_state suspend
Definition: gdbthread.h:202
int fake_pid_p
Definition: inferior.h:301
void ** data
Definition: gdbarch.c:139
struct inferior * current_inferior(void)
Definition: inferior.c:57
unsigned long long ULONGEST
Definition: common-types.h:53
static int linux_find_memory_regions_full(struct gdbarch *gdbarch, linux_find_memory_region_ftype *func, void *obfd)
Definition: linux-tdep.c:1111
long ptid_get_lwp(ptid_t ptid)
Definition: ptid.c:60
#define obstack_grow_str0(OBSTACK, STRING)
Definition: gdb_obstack.h:48
int length
Definition: memrange.h:33
enum thread_state state
Definition: gdbthread.h:189
LONGEST target_read(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *buf, ULONGEST offset, LONGEST len)
Definition: target.c:1590
struct value * value_from_ulongest(struct type *type, ULONGEST num)
Definition: value.c:3476
CORE_ADDR value_as_address(struct value *val)
Definition: value.c:2679
static int linux_corefile_thread_callback(struct thread_info *info, void *data)
Definition: linux-tdep.c:1666
static struct linux_info * get_linux_inferior_data(void)
Definition: linux-tdep.c:228
static int use_coredump_filter
Definition: linux-tdep.c:91
bfd * core_bfd
Definition: corefile.c:58
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
#define HOST_CHAR_BIT
Definition: host-defs.h:40
unsigned int io_page
Definition: linux-tdep.c:73
Definition: defs.h:455
struct type * arch_type(struct gdbarch *gdbarch, enum type_code code, int length, char *name)
Definition: gdbtypes.c:4532
struct cleanup * make_cleanup_obstack_free(struct obstack *obstack)
Definition: utils.c:225
int(* find_memory_region_ftype)(CORE_ADDR addr, unsigned long size, int read, int write, int exec, int modified, void *data)
Definition: defs.h:343
void pack_long(gdb_byte *buf, struct type *type, LONGEST num)
Definition: value.c:3392
struct type * gdbarch_get_siginfo_type(struct gdbarch *gdbarch)
Definition: gdbarch.c:3967
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
unsigned int shared_mapping
Definition: linux-tdep.c:85
struct gdbarch_data * gdbarch_data_register_post_init(gdbarch_data_post_init_ftype *post_init)
Definition: gdbarch.c:4812
#define skip_to_space(INP)
Definition: common-utils.h:94
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1818
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:368
long long LONGEST
Definition: common-types.h:52
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void set_gdbarch_vsyscall_range(struct gdbarch *gdbarch, gdbarch_vsyscall_range_ftype vsyscall_range)
Definition: gdbarch.c:4665
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
struct regcache * get_thread_arch_regcache(ptid_t ptid, struct gdbarch *gdbarch)
Definition: regcache.c:508
static struct gdbarch_data * linux_gdbarch_data_handle
Definition: linux-tdep.c:158
static struct gdbarch * core_gdbarch
Definition: corelow.c:67
void gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
Definition: gdbarch.c:3388
CORE_ADDR start
Definition: memrange.h:30
collect_regset_ftype * collect_regset
Definition: regset.h:45