GDB (xrefs)
Loading...
Searching...
No Matches
/tmp/gdb-13.1/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-2023 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 "gdbsupport/gdb_obstack.h"
35#include "observable.h"
36#include "objfiles.h"
37#include "infcall.h"
38#include "gdbcmd.h"
39#include "gdbsupport/gdb_regex.h"
40#include "gdbsupport/enum-flags.h"
41#include "gdbsupport/gdb_optional.h"
42#include "gcore.h"
43#include "gcore-elf.h"
44#include "solib-svr4.h"
45#include "memtag.h"
46
47#include <ctype.h>
48#include <unordered_map>
49
50/* This enum represents the values that the user can choose when
51 informing the Linux kernel about which memory mappings will be
52 dumped in a corefile. They are described in the file
53 Documentation/filesystems/proc.txt, inside the Linux kernel
54 tree. */
55
57 {
65 };
66DEF_ENUM_FLAGS_TYPE (enum filter_flag, filter_flags);
67
68/* This struct is used to map flags found in the "VmFlags:" field (in
69 the /proc/<PID>/smaps file). */
70
72 {
73 /* Zero if this structure has not been initialized yet. It
74 probably means that the Linux kernel being used does not emit
75 the "VmFlags:" field on "/proc/PID/smaps". */
76
77 unsigned int initialized_p : 1;
78
79 /* Memory mapped I/O area (VM_IO, "io"). */
80
81 unsigned int io_page : 1;
82
83 /* Area uses huge TLB pages (VM_HUGETLB, "ht"). */
84
85 unsigned int uses_huge_tlb : 1;
86
87 /* Do not include this memory region on the coredump (VM_DONTDUMP, "dd"). */
88
89 unsigned int exclude_coredump : 1;
90
91 /* Is this a MAP_SHARED mapping (VM_SHARED, "sh"). */
92
93 unsigned int shared_mapping : 1;
94
95 /* Memory map has memory tagging enabled. */
96
97 unsigned int memory_tagging : 1;
98 };
99
100/* Data structure that holds the information contained in the
101 /proc/<pid>/smaps file. */
102
104{
106 ULONGEST end_address;
107 std::string filename;
109 bool read;
110 bool write;
111 bool exec;
112 bool priv;
116
117 ULONGEST inode;
118 ULONGEST offset;
119};
120
121/* Whether to take the /proc/PID/coredump_filter into account when
122 generating a corefile. */
123
124static bool use_coredump_filter = true;
125
126/* Whether the value of smaps_vmflags->exclude_coredump should be
127 ignored, including mappings marked with the VM_DONTDUMP flag in
128 the dump. */
129static bool dump_excluded_mappings = false;
130
131/* This enum represents the signals' numbers on a generic architecture
132 running the Linux kernel. The definition of "generic" comes from
133 the file <include/uapi/asm-generic/signal.h>, from the Linux kernel
134 tree, which is the "de facto" implementation of signal numbers to
135 be used by new architecture ports.
136
137 For those architectures which have differences between the generic
138 standard (e.g., Alpha), we define the different signals (and *only*
139 those) in the specific target-dependent file (e.g.,
140 alpha-linux-tdep.c, for Alpha). Please refer to the architecture's
141 tdep file for more information.
142
143 ARM deserves a special mention here. On the file
144 <arch/arm/include/uapi/asm/signal.h>, it defines only one different
145 (and ARM-only) signal, which is SIGSWI, with the same number as
146 SIGRTMIN. This signal is used only for a very specific target,
147 called ArthurOS (from RISCOS). Therefore, we do not handle it on
148 the ARM-tdep file, and we can safely use the generic signal handler
149 here for ARM targets.
150
151 As stated above, this enum is derived from
152 <include/uapi/asm-generic/signal.h>, from the Linux kernel
153 tree. */
154
155enum
156 {
191
194 };
195
197{
198 struct type *siginfo_type = nullptr;
200};
201
204
205static struct linux_gdbarch_data *
207{
209 if (result == nullptr)
210 result = linux_gdbarch_data_handle.emplace (gdbarch);
211 return result;
212}
213
214/* Linux-specific cached data. This is used by GDB for caching
215 purposes for each inferior. This helps reduce the overhead of
216 transfering data from a remote target to the local host. */
218{
219 /* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
220 if VSYSCALL_RANGE_P is positive. This is cached because getting
221 at this info requires an auxv lookup (which is itself cached),
222 and looking through the inferior's mappings (which change
223 throughout execution and therefore cannot be cached). */
225
226 /* Zero if we haven't tried looking up the vsyscall's range before
227 yet. Positive if we tried looking it up, and found it. Negative
228 if we tried looking it up but failed. */
230
231 /* Inferior's displaced step buffers. */
232 gdb::optional<displaced_step_buffers> disp_step_bufs;
233};
234
235/* Per-inferior data key. */
237
238/* Frees whatever allocated space there is to be freed and sets INF's
239 linux cache data pointer to NULL. */
240
241static void
243{
244 linux_inferior_data.clear (inf);
245}
246
247/* Fetch the linux cache info for INF. This function always returns a
248 valid INFO pointer. */
249
250static struct linux_info *
252{
254
255 if (info == nullptr)
256 info = linux_inferior_data.emplace (inf);
257
258 return info;
259}
260
261/* See linux-tdep.h. */
262
263struct type *
265 linux_siginfo_extra_fields extra_fields)
266{
268 struct type *int_type, *uint_type, *long_type, *void_ptr_type, *short_type;
269 struct type *uid_type, *pid_type;
270 struct type *sigval_type, *clock_type;
271 struct type *siginfo_type, *sifields_type;
272 struct type *type;
273
275 if (linux_gdbarch_data->siginfo_type != NULL)
277
279 0, "int");
281 1, "unsigned int");
283 0, "long");
285 0, "short");
286 void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
287
288 /* sival_t */
289 sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
290 sigval_type->set_name (xstrdup ("sigval_t"));
291 append_composite_type_field (sigval_type, "sival_int", int_type);
292 append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
293
294 /* __pid_t */
295 pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
296 int_type->length () * TARGET_CHAR_BIT, "__pid_t");
297 pid_type->set_target_type (int_type);
298 pid_type->set_target_is_stub (true);
299
300 /* __uid_t */
301 uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
302 uint_type->length () * TARGET_CHAR_BIT, "__uid_t");
303 uid_type->set_target_type (uint_type);
304 uid_type->set_target_is_stub (true);
305
306 /* __clock_t */
307 clock_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
308 long_type->length () * TARGET_CHAR_BIT,
309 "__clock_t");
310 clock_type->set_target_type (long_type);
311 clock_type->set_target_is_stub (true);
312
313 /* _sifields */
314 sifields_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
315
316 {
317 const int si_max_size = 128;
318 int si_pad_size;
319 int size_of_int = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
320
321 /* _pad */
322 if (gdbarch_ptr_bit (gdbarch) == 64)
323 si_pad_size = (si_max_size / size_of_int) - 4;
324 else
325 si_pad_size = (si_max_size / size_of_int) - 3;
326 append_composite_type_field (sifields_type, "_pad",
327 init_vector_type (int_type, si_pad_size));
328 }
329
330 /* _kill */
331 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
332 append_composite_type_field (type, "si_pid", pid_type);
333 append_composite_type_field (type, "si_uid", uid_type);
334 append_composite_type_field (sifields_type, "_kill", type);
335
336 /* _timer */
337 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
338 append_composite_type_field (type, "si_tid", int_type);
339 append_composite_type_field (type, "si_overrun", int_type);
340 append_composite_type_field (type, "si_sigval", sigval_type);
341 append_composite_type_field (sifields_type, "_timer", type);
342
343 /* _rt */
344 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
345 append_composite_type_field (type, "si_pid", pid_type);
346 append_composite_type_field (type, "si_uid", uid_type);
347 append_composite_type_field (type, "si_sigval", sigval_type);
348 append_composite_type_field (sifields_type, "_rt", type);
349
350 /* _sigchld */
351 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
352 append_composite_type_field (type, "si_pid", pid_type);
353 append_composite_type_field (type, "si_uid", uid_type);
354 append_composite_type_field (type, "si_status", int_type);
355 append_composite_type_field (type, "si_utime", clock_type);
356 append_composite_type_field (type, "si_stime", clock_type);
357 append_composite_type_field (sifields_type, "_sigchld", type);
358
359 /* _sigfault */
360 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
361 append_composite_type_field (type, "si_addr", void_ptr_type);
362
363 /* Additional bound fields for _sigfault in case they were requested. */
364 if ((extra_fields & LINUX_SIGINFO_FIELD_ADDR_BND) != 0)
365 {
366 struct type *sigfault_bnd_fields;
367
368 append_composite_type_field (type, "_addr_lsb", short_type);
369 sigfault_bnd_fields = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
370 append_composite_type_field (sigfault_bnd_fields, "_lower", void_ptr_type);
371 append_composite_type_field (sigfault_bnd_fields, "_upper", void_ptr_type);
372 append_composite_type_field (type, "_addr_bnd", sigfault_bnd_fields);
373 }
374 append_composite_type_field (sifields_type, "_sigfault", type);
375
376 /* _sigpoll */
377 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
378 append_composite_type_field (type, "si_band", long_type);
379 append_composite_type_field (type, "si_fd", int_type);
380 append_composite_type_field (sifields_type, "_sigpoll", type);
381
382 /* _sigsys */
383 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
384 append_composite_type_field (type, "_call_addr", void_ptr_type);
385 append_composite_type_field (type, "_syscall", int_type);
386 append_composite_type_field (type, "_arch", uint_type);
387 append_composite_type_field (sifields_type, "_sigsys", type);
388
389 /* struct siginfo */
390 siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
391 siginfo_type->set_name (xstrdup ("siginfo"));
392 append_composite_type_field (siginfo_type, "si_signo", int_type);
393 append_composite_type_field (siginfo_type, "si_errno", int_type);
394 append_composite_type_field (siginfo_type, "si_code", int_type);
396 "_sifields", sifields_type,
397 long_type->length ());
398
399 linux_gdbarch_data->siginfo_type = siginfo_type;
400
401 return siginfo_type;
402}
403
404/* This function is suitable for architectures that don't
405 extend/override the standard siginfo structure. */
406
407static struct type *
409{
411}
412
413/* Return true if the target is running on uClinux instead of normal
414 Linux kernel. */
415
416int
418{
419 CORE_ADDR dummy;
420
421 return (target_auxv_search (AT_NULL, &dummy) > 0
422 && target_auxv_search (AT_PAGESZ, &dummy) == 0);
423}
424
425static int
427{
428 return linux_is_uclinux ();
429}
430
431/* This is how we want PTIDs from core files to be printed. */
432
433static std::string
435{
436 if (ptid.lwp () != 0)
437 return string_printf ("LWP %ld", ptid.lwp ());
438
439 return normal_pid_to_str (ptid);
440}
441
442/* Data from one mapping from /proc/PID/maps. */
443
445{
446 ULONGEST addr;
447 ULONGEST endaddr;
448 gdb::string_view permissions;
449 ULONGEST offset;
450 gdb::string_view device;
451 ULONGEST inode;
452
453 /* This field is guaranteed to be NULL-terminated, hence it is not a
454 gdb::string_view. */
455 const char *filename;
456};
457
458/* Service function for corefiles and info proc. */
459
460static mapping
461read_mapping (const char *line)
462{
463 struct mapping mapping;
464 const char *p = line;
465
466 mapping.addr = strtoulst (p, &p, 16);
467 if (*p == '-')
468 p++;
469 mapping.endaddr = strtoulst (p, &p, 16);
470
471 p = skip_spaces (p);
472 const char *permissions_start = p;
473 while (*p && !isspace (*p))
474 p++;
475 mapping.permissions = {permissions_start, (size_t) (p - permissions_start)};
476
477 mapping.offset = strtoulst (p, &p, 16);
478
479 p = skip_spaces (p);
480 const char *device_start = p;
481 while (*p && !isspace (*p))
482 p++;
483 mapping.device = {device_start, (size_t) (p - device_start)};
484
485 mapping.inode = strtoulst (p, &p, 10);
486
487 p = skip_spaces (p);
488 mapping.filename = p;
489
490 return mapping;
491}
492
493/* Helper function to decode the "VmFlags" field in /proc/PID/smaps.
494
495 This function was based on the documentation found on
496 <Documentation/filesystems/proc.txt>, on the Linux kernel.
497
498 Linux kernels before commit
499 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have this
500 field on smaps. */
501
502static void
503decode_vmflags (char *p, struct smaps_vmflags *v)
504{
505 char *saveptr = NULL;
506 const char *s;
507
508 v->initialized_p = 1;
509 p = skip_to_space (p);
510 p = skip_spaces (p);
511
512 for (s = strtok_r (p, " ", &saveptr);
513 s != NULL;
514 s = strtok_r (NULL, " ", &saveptr))
515 {
516 if (strcmp (s, "io") == 0)
517 v->io_page = 1;
518 else if (strcmp (s, "ht") == 0)
519 v->uses_huge_tlb = 1;
520 else if (strcmp (s, "dd") == 0)
521 v->exclude_coredump = 1;
522 else if (strcmp (s, "sh") == 0)
523 v->shared_mapping = 1;
524 else if (strcmp (s, "mt") == 0)
525 v->memory_tagging = 1;
526 }
527}
528
529/* Regexes used by mapping_is_anonymous_p. Put in a structure because
530 they're initialized lazily. */
531
533{
534 /* Matches "/dev/zero" filenames (with or without the "(deleted)"
535 string in the end). We know for sure, based on the Linux kernel
536 code, that memory mappings whose associated filename is
537 "/dev/zero" are guaranteed to be MAP_ANONYMOUS. */
538 compiled_regex dev_zero
539 {"^/dev/zero\\( (deleted)\\)\\?$", REG_NOSUB,
540 _("Could not compile regex to match /dev/zero filename")};
541
542 /* Matches "/SYSV%08x" filenames (with or without the "(deleted)"
543 string in the end). These filenames refer to shared memory
544 (shmem), and memory mappings associated with them are
545 MAP_ANONYMOUS as well. */
546 compiled_regex shmem_file
547 {"^/\\?SYSV[0-9a-fA-F]\\{8\\}\\( (deleted)\\)\\?$", REG_NOSUB,
548 _("Could not compile regex to match shmem filenames")};
549
550 /* A heuristic we use to try to mimic the Linux kernel's 'n_link ==
551 0' code, which is responsible to decide if it is dealing with a
552 'MAP_SHARED | MAP_ANONYMOUS' mapping. In other words, if
553 FILE_DELETED matches, it does not necessarily mean that we are
554 dealing with an anonymous shared mapping. However, there is no
555 easy way to detect this currently, so this is the best
556 approximation we have.
557
558 As a result, GDB will dump readonly pages of deleted executables
559 when using the default value of coredump_filter (0x33), while the
560 Linux kernel will not dump those pages. But we can live with
561 that. */
562 compiled_regex file_deleted
563 {" (deleted)$", REG_NOSUB,
564 _("Could not compile regex to match '<file> (deleted)'")};
565};
566
567/* Return 1 if the memory mapping is anonymous, 0 otherwise.
568
569 FILENAME is the name of the file present in the first line of the
570 memory mapping, in the "/proc/PID/smaps" output. For example, if
571 the first line is:
572
573 7fd0ca877000-7fd0d0da0000 r--p 00000000 fd:02 2100770 /path/to/file
574
575 Then FILENAME will be "/path/to/file". */
576
577static int
578mapping_is_anonymous_p (const char *filename)
579{
580 static gdb::optional<mapping_regexes> regexes;
581 static int init_regex_p = 0;
582
583 if (!init_regex_p)
584 {
585 /* Let's be pessimistic and assume there will be an error while
586 compiling the regex'es. */
587 init_regex_p = -1;
588
589 regexes.emplace ();
590
591 /* If we reached this point, then everything succeeded. */
592 init_regex_p = 1;
593 }
594
595 if (init_regex_p == -1)
596 {
597 const char deleted[] = " (deleted)";
598 size_t del_len = sizeof (deleted) - 1;
599 size_t filename_len = strlen (filename);
600
601 /* There was an error while compiling the regex'es above. In
602 order to try to give some reliable information to the caller,
603 we just try to find the string " (deleted)" in the filename.
604 If we managed to find it, then we assume the mapping is
605 anonymous. */
606 return (filename_len >= del_len
607 && strcmp (filename + filename_len - del_len, deleted) == 0);
608 }
609
610 if (*filename == '\0'
611 || regexes->dev_zero.exec (filename, 0, NULL, 0) == 0
612 || regexes->shmem_file.exec (filename, 0, NULL, 0) == 0
613 || regexes->file_deleted.exec (filename, 0, NULL, 0) == 0)
614 return 1;
615
616 return 0;
617}
618
619/* Return 0 if the memory mapping (which is related to FILTERFLAGS, V,
620 MAYBE_PRIVATE_P, MAPPING_ANONYMOUS_P, ADDR and OFFSET) should not
621 be dumped, or greater than 0 if it should.
622
623 In a nutshell, this is the logic that we follow in order to decide
624 if a mapping should be dumped or not.
625
626 - If the mapping is associated to a file whose name ends with
627 " (deleted)", or if the file is "/dev/zero", or if it is
628 "/SYSV%08x" (shared memory), or if there is no file associated
629 with it, or if the AnonHugePages: or the Anonymous: fields in the
630 /proc/PID/smaps have contents, then GDB considers this mapping to
631 be anonymous. Otherwise, GDB considers this mapping to be a
632 file-backed mapping (because there will be a file associated with
633 it).
634
635 It is worth mentioning that, from all those checks described
636 above, the most fragile is the one to see if the file name ends
637 with " (deleted)". This does not necessarily mean that the
638 mapping is anonymous, because the deleted file associated with
639 the mapping may have been a hard link to another file, for
640 example. The Linux kernel checks to see if "i_nlink == 0", but
641 GDB cannot easily (and normally) do this check (iff running as
642 root, it could find the mapping in /proc/PID/map_files/ and
643 determine whether there still are other hard links to the
644 inode/file). Therefore, we made a compromise here, and we assume
645 that if the file name ends with " (deleted)", then the mapping is
646 indeed anonymous. FWIW, this is something the Linux kernel could
647 do better: expose this information in a more direct way.
648
649 - If we see the flag "sh" in the "VmFlags:" field (in
650 /proc/PID/smaps), then certainly the memory mapping is shared
651 (VM_SHARED). If we have access to the VmFlags, and we don't see
652 the "sh" there, then certainly the mapping is private. However,
653 Linux kernels before commit
654 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10) do not have the
655 "VmFlags:" field; in that case, we use another heuristic: if we
656 see 'p' in the permission flags, then we assume that the mapping
657 is private, even though the presence of the 's' flag there would
658 mean VM_MAYSHARE, which means the mapping could still be private.
659 This should work OK enough, however.
660
661 - Even if, at the end, we decided that we should not dump the
662 mapping, we still have to check if it is something like an ELF
663 header (of a DSO or an executable, for example). If it is, and
664 if the user is interested in dump it, then we should dump it. */
665
666static int
667dump_mapping_p (filter_flags filterflags, const struct smaps_vmflags *v,
668 int maybe_private_p, int mapping_anon_p, int mapping_file_p,
669 const char *filename, ULONGEST addr, ULONGEST offset)
670{
671 /* Initially, we trust in what we received from our caller. This
672 value may not be very precise (i.e., it was probably gathered
673 from the permission line in the /proc/PID/smaps list, which
674 actually refers to VM_MAYSHARE, and not VM_SHARED), but it is
675 what we have until we take a look at the "VmFlags:" field
676 (assuming that the version of the Linux kernel being used
677 supports it, of course). */
678 int private_p = maybe_private_p;
679 int dump_p;
680
681 /* We always dump vDSO and vsyscall mappings, because it's likely that
682 there'll be no file to read the contents from at core load time.
683 The kernel does the same. */
684 if (strcmp ("[vdso]", filename) == 0
685 || strcmp ("[vsyscall]", filename) == 0)
686 return 1;
687
688 if (v->initialized_p)
689 {
690 /* We never dump I/O mappings. */
691 if (v->io_page)
692 return 0;
693
694 /* Check if we should exclude this mapping. */
696 return 0;
697
698 /* Update our notion of whether this mapping is shared or
699 private based on a trustworthy value. */
700 private_p = !v->shared_mapping;
701
702 /* HugeTLB checking. */
703 if (v->uses_huge_tlb)
704 {
705 if ((private_p && (filterflags & COREFILTER_HUGETLB_PRIVATE))
706 || (!private_p && (filterflags & COREFILTER_HUGETLB_SHARED)))
707 return 1;
708
709 return 0;
710 }
711 }
712
713 if (private_p)
714 {
715 if (mapping_anon_p && mapping_file_p)
716 {
717 /* This is a special situation. It can happen when we see a
718 mapping that is file-backed, but that contains anonymous
719 pages. */
720 dump_p = ((filterflags & COREFILTER_ANON_PRIVATE) != 0
721 || (filterflags & COREFILTER_MAPPED_PRIVATE) != 0);
722 }
723 else if (mapping_anon_p)
724 dump_p = (filterflags & COREFILTER_ANON_PRIVATE) != 0;
725 else
726 dump_p = (filterflags & COREFILTER_MAPPED_PRIVATE) != 0;
727 }
728 else
729 {
730 if (mapping_anon_p && mapping_file_p)
731 {
732 /* This is a special situation. It can happen when we see a
733 mapping that is file-backed, but that contains anonymous
734 pages. */
735 dump_p = ((filterflags & COREFILTER_ANON_SHARED) != 0
736 || (filterflags & COREFILTER_MAPPED_SHARED) != 0);
737 }
738 else if (mapping_anon_p)
739 dump_p = (filterflags & COREFILTER_ANON_SHARED) != 0;
740 else
741 dump_p = (filterflags & COREFILTER_MAPPED_SHARED) != 0;
742 }
743
744 /* Even if we decided that we shouldn't dump this mapping, we still
745 have to check whether (a) the user wants us to dump mappings
746 containing an ELF header, and (b) the mapping in question
747 contains an ELF header. If (a) and (b) are true, then we should
748 dump this mapping.
749
750 A mapping contains an ELF header if it is a private mapping, its
751 offset is zero, and its first word is ELFMAG. */
752 if (!dump_p && private_p && offset == 0
753 && (filterflags & COREFILTER_ELF_HEADERS) != 0)
754 {
755 /* Useful define specifying the size of the ELF magical
756 header. */
757#ifndef SELFMAG
758#define SELFMAG 4
759#endif
760
761 /* Let's check if we have an ELF header. */
762 gdb_byte h[SELFMAG];
763 if (target_read_memory (addr, h, SELFMAG) == 0)
764 {
765 /* The EI_MAG* and ELFMAG* constants come from
766 <elf/common.h>. */
767 if (h[EI_MAG0] == ELFMAG0 && h[EI_MAG1] == ELFMAG1
768 && h[EI_MAG2] == ELFMAG2 && h[EI_MAG3] == ELFMAG3)
769 {
770 /* This mapping contains an ELF header, so we
771 should dump it. */
772 dump_p = 1;
773 }
774 }
775 }
776
777 return dump_p;
778}
779
780/* As above, but return true only when we should dump the NT_FILE
781 entry. */
782
783static int
784dump_note_entry_p (filter_flags filterflags, const struct smaps_vmflags *v,
785 int maybe_private_p, int mapping_anon_p, int mapping_file_p,
786 const char *filename, ULONGEST addr, ULONGEST offset)
787{
788 /* vDSO and vsyscall mappings will end up in the core file. Don't
789 put them in the NT_FILE note. */
790 if (strcmp ("[vdso]", filename) == 0
791 || strcmp ("[vsyscall]", filename) == 0)
792 return 0;
793
794 /* Otherwise, any other file-based mapping should be placed in the
795 note. */
796 return 1;
797}
798
799/* Implement the "info proc" command. */
800
801static void
802linux_info_proc (struct gdbarch *gdbarch, const char *args,
803 enum info_proc_what what)
804{
805 /* A long is used for pid instead of an int to avoid a loss of precision
806 compiler warning from the output of strtoul. */
807 long pid;
808 int cmdline_f = (what == IP_MINIMAL || what == IP_CMDLINE || what == IP_ALL);
809 int cwd_f = (what == IP_MINIMAL || what == IP_CWD || what == IP_ALL);
810 int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
811 int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
812 int status_f = (what == IP_STATUS || what == IP_ALL);
813 int stat_f = (what == IP_STAT || what == IP_ALL);
814 char filename[100];
815 fileio_error target_errno;
816
817 if (args && isdigit (args[0]))
818 {
819 char *tem;
820
821 pid = strtoul (args, &tem, 10);
822 args = tem;
823 }
824 else
825 {
826 if (!target_has_execution ())
827 error (_("No current process: you must name one."));
828 if (current_inferior ()->fake_pid_p)
829 error (_("Can't determine the current process's PID: you must name one."));
830
832 }
833
834 args = skip_spaces (args);
835 if (args && args[0])
836 error (_("Too many parameters: %s"), args);
837
838 gdb_printf (_("process %ld\n"), pid);
839 if (cmdline_f)
840 {
841 xsnprintf (filename, sizeof filename, "/proc/%ld/cmdline", pid);
842 gdb_byte *buffer;
843 ssize_t len = target_fileio_read_alloc (NULL, filename, &buffer);
844
845 if (len > 0)
846 {
847 gdb::unique_xmalloc_ptr<char> cmdline ((char *) buffer);
848 ssize_t pos;
849
850 for (pos = 0; pos < len - 1; pos++)
851 {
852 if (buffer[pos] == '\0')
853 buffer[pos] = ' ';
854 }
855 buffer[len - 1] = '\0';
856 gdb_printf ("cmdline = '%s'\n", buffer);
857 }
858 else
859 warning (_("unable to open /proc file '%s'"), filename);
860 }
861 if (cwd_f)
862 {
863 xsnprintf (filename, sizeof filename, "/proc/%ld/cwd", pid);
864 gdb::optional<std::string> contents
865 = target_fileio_readlink (NULL, filename, &target_errno);
866 if (contents.has_value ())
867 gdb_printf ("cwd = '%s'\n", contents->c_str ());
868 else
869 warning (_("unable to read link '%s'"), filename);
870 }
871 if (exe_f)
872 {
873 xsnprintf (filename, sizeof filename, "/proc/%ld/exe", pid);
874 gdb::optional<std::string> contents
875 = target_fileio_readlink (NULL, filename, &target_errno);
876 if (contents.has_value ())
877 gdb_printf ("exe = '%s'\n", contents->c_str ());
878 else
879 warning (_("unable to read link '%s'"), filename);
880 }
881 if (mappings_f)
882 {
883 xsnprintf (filename, sizeof filename, "/proc/%ld/maps", pid);
884 gdb::unique_xmalloc_ptr<char> map
885 = target_fileio_read_stralloc (NULL, filename);
886 if (map != NULL)
887 {
888 char *line;
889
890 gdb_printf (_("Mapped address spaces:\n\n"));
891 if (gdbarch_addr_bit (gdbarch) == 32)
892 {
893 gdb_printf ("\t%10s %10s %10s %10s %s %s\n",
894 "Start Addr", " End Addr", " Size",
895 " Offset", "Perms ", "objfile");
896 }
897 else
898 {
899 gdb_printf (" %18s %18s %10s %10s %s %s\n",
900 "Start Addr", " End Addr", " Size",
901 " Offset", "Perms ", "objfile");
902 }
903
904 char *saveptr;
905 for (line = strtok_r (map.get (), "\n", &saveptr);
906 line;
907 line = strtok_r (NULL, "\n", &saveptr))
908 {
909 struct mapping m = read_mapping (line);
910
911 if (gdbarch_addr_bit (gdbarch) == 32)
912 {
913 gdb_printf ("\t%10s %10s %10s %10s %-5.*s %s\n",
914 paddress (gdbarch, m.addr),
915 paddress (gdbarch, m.endaddr),
916 hex_string (m.endaddr - m.addr),
917 hex_string (m.offset),
918 (int) m.permissions.size (),
919 m.permissions.data (),
920 m.filename);
921 }
922 else
923 {
924 gdb_printf (" %18s %18s %10s %10s %-5.*s %s\n",
925 paddress (gdbarch, m.addr),
926 paddress (gdbarch, m.endaddr),
927 hex_string (m.endaddr - m.addr),
928 hex_string (m.offset),
929 (int) m.permissions.size (),
930 m.permissions.data (),
931 m.filename);
932 }
933 }
934 }
935 else
936 warning (_("unable to open /proc file '%s'"), filename);
937 }
938 if (status_f)
939 {
940 xsnprintf (filename, sizeof filename, "/proc/%ld/status", pid);
941 gdb::unique_xmalloc_ptr<char> status
943 if (status)
944 gdb_puts (status.get ());
945 else
946 warning (_("unable to open /proc file '%s'"), filename);
947 }
948 if (stat_f)
949 {
950 xsnprintf (filename, sizeof filename, "/proc/%ld/stat", pid);
951 gdb::unique_xmalloc_ptr<char> statstr
953 if (statstr)
954 {
955 const char *p = statstr.get ();
956
957 gdb_printf (_("Process: %s\n"),
958 pulongest (strtoulst (p, &p, 10)));
959
960 p = skip_spaces (p);
961 if (*p == '(')
962 {
963 /* ps command also relies on no trailing fields
964 ever contain ')'. */
965 const char *ep = strrchr (p, ')');
966 if (ep != NULL)
967 {
968 gdb_printf ("Exec file: %.*s\n",
969 (int) (ep - p - 1), p + 1);
970 p = ep + 1;
971 }
972 }
973
974 p = skip_spaces (p);
975 if (*p)
976 gdb_printf (_("State: %c\n"), *p++);
977
978 if (*p)
979 gdb_printf (_("Parent process: %s\n"),
980 pulongest (strtoulst (p, &p, 10)));
981 if (*p)
982 gdb_printf (_("Process group: %s\n"),
983 pulongest (strtoulst (p, &p, 10)));
984 if (*p)
985 gdb_printf (_("Session id: %s\n"),
986 pulongest (strtoulst (p, &p, 10)));
987 if (*p)
988 gdb_printf (_("TTY: %s\n"),
989 pulongest (strtoulst (p, &p, 10)));
990 if (*p)
991 gdb_printf (_("TTY owner process group: %s\n"),
992 pulongest (strtoulst (p, &p, 10)));
993
994 if (*p)
995 gdb_printf (_("Flags: %s\n"),
996 hex_string (strtoulst (p, &p, 10)));
997 if (*p)
998 gdb_printf (_("Minor faults (no memory page): %s\n"),
999 pulongest (strtoulst (p, &p, 10)));
1000 if (*p)
1001 gdb_printf (_("Minor faults, children: %s\n"),
1002 pulongest (strtoulst (p, &p, 10)));
1003 if (*p)
1004 gdb_printf (_("Major faults (memory page faults): %s\n"),
1005 pulongest (strtoulst (p, &p, 10)));
1006 if (*p)
1007 gdb_printf (_("Major faults, children: %s\n"),
1008 pulongest (strtoulst (p, &p, 10)));
1009 if (*p)
1010 gdb_printf (_("utime: %s\n"),
1011 pulongest (strtoulst (p, &p, 10)));
1012 if (*p)
1013 gdb_printf (_("stime: %s\n"),
1014 pulongest (strtoulst (p, &p, 10)));
1015 if (*p)
1016 gdb_printf (_("utime, children: %s\n"),
1017 pulongest (strtoulst (p, &p, 10)));
1018 if (*p)
1019 gdb_printf (_("stime, children: %s\n"),
1020 pulongest (strtoulst (p, &p, 10)));
1021 if (*p)
1022 gdb_printf (_("jiffies remaining in current "
1023 "time slice: %s\n"),
1024 pulongest (strtoulst (p, &p, 10)));
1025 if (*p)
1026 gdb_printf (_("'nice' value: %s\n"),
1027 pulongest (strtoulst (p, &p, 10)));
1028 if (*p)
1029 gdb_printf (_("jiffies until next timeout: %s\n"),
1030 pulongest (strtoulst (p, &p, 10)));
1031 if (*p)
1032 gdb_printf (_("jiffies until next SIGALRM: %s\n"),
1033 pulongest (strtoulst (p, &p, 10)));
1034 if (*p)
1035 gdb_printf (_("start time (jiffies since "
1036 "system boot): %s\n"),
1037 pulongest (strtoulst (p, &p, 10)));
1038 if (*p)
1039 gdb_printf (_("Virtual memory size: %s\n"),
1040 pulongest (strtoulst (p, &p, 10)));
1041 if (*p)
1042 gdb_printf (_("Resident set size: %s\n"),
1043 pulongest (strtoulst (p, &p, 10)));
1044 if (*p)
1045 gdb_printf (_("rlim: %s\n"),
1046 pulongest (strtoulst (p, &p, 10)));
1047 if (*p)
1048 gdb_printf (_("Start of text: %s\n"),
1049 hex_string (strtoulst (p, &p, 10)));
1050 if (*p)
1051 gdb_printf (_("End of text: %s\n"),
1052 hex_string (strtoulst (p, &p, 10)));
1053 if (*p)
1054 gdb_printf (_("Start of stack: %s\n"),
1055 hex_string (strtoulst (p, &p, 10)));
1056#if 0 /* Don't know how architecture-dependent the rest is...
1057 Anyway the signal bitmap info is available from "status". */
1058 if (*p)
1059 gdb_printf (_("Kernel stack pointer: %s\n"),
1060 hex_string (strtoulst (p, &p, 10)));
1061 if (*p)
1062 gdb_printf (_("Kernel instr pointer: %s\n"),
1063 hex_string (strtoulst (p, &p, 10)));
1064 if (*p)
1065 gdb_printf (_("Pending signals bitmap: %s\n"),
1066 hex_string (strtoulst (p, &p, 10)));
1067 if (*p)
1068 gdb_printf (_("Blocked signals bitmap: %s\n"),
1069 hex_string (strtoulst (p, &p, 10)));
1070 if (*p)
1071 gdb_printf (_("Ignored signals bitmap: %s\n"),
1072 hex_string (strtoulst (p, &p, 10)));
1073 if (*p)
1074 gdb_printf (_("Catched signals bitmap: %s\n"),
1075 hex_string (strtoulst (p, &p, 10)));
1076 if (*p)
1077 gdb_printf (_("wchan (system call): %s\n"),
1078 hex_string (strtoulst (p, &p, 10)));
1079#endif
1080 }
1081 else
1082 warning (_("unable to open /proc file '%s'"), filename);
1083 }
1084}
1085
1086/* Implementation of `gdbarch_read_core_file_mappings', as defined in
1087 gdbarch.h.
1088
1089 This function reads the NT_FILE note (which BFD turns into the
1090 section ".note.linuxcore.file"). The format of this note / section
1091 is described as follows in the Linux kernel sources in
1092 fs/binfmt_elf.c:
1093
1094 long count -- how many files are mapped
1095 long page_size -- units for file_ofs
1096 array of [COUNT] elements of
1097 long start
1098 long end
1099 long file_ofs
1100 followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1101
1102 CBFD is the BFD of the core file.
1103
1104 PRE_LOOP_CB is the callback function to invoke prior to starting
1105 the loop which processes individual entries. This callback will
1106 only be executed after the note has been examined in enough
1107 detail to verify that it's not malformed in some way.
1108
1109 LOOP_CB is the callback function that will be executed once
1110 for each mapping. */
1111
1112static void
1114 (struct gdbarch *gdbarch,
1115 struct bfd *cbfd,
1118{
1119 /* Ensure that ULONGEST is big enough for reading 64-bit core files. */
1120 gdb_static_assert (sizeof (ULONGEST) >= 8);
1121
1122 /* It's not required that the NT_FILE note exists, so return silently
1123 if it's not found. Beyond this point though, we'll complain
1124 if problems are found. */
1125 asection *section = bfd_get_section_by_name (cbfd, ".note.linuxcore.file");
1126 if (section == nullptr)
1127 return;
1128
1129 unsigned int addr_size_bits = gdbarch_addr_bit (gdbarch);
1130 unsigned int addr_size = addr_size_bits / 8;
1131 size_t note_size = bfd_section_size (section);
1132
1133 if (note_size < 2 * addr_size)
1134 {
1135 warning (_("malformed core note - too short for header"));
1136 return;
1137 }
1138
1139 gdb::def_vector<gdb_byte> contents (note_size);
1140 if (!bfd_get_section_contents (core_bfd, section, contents.data (),
1141 0, note_size))
1142 {
1143 warning (_("could not get core note contents"));
1144 return;
1145 }
1146
1147 gdb_byte *descdata = contents.data ();
1148 char *descend = (char *) descdata + note_size;
1149
1150 if (descdata[note_size - 1] != '\0')
1151 {
1152 warning (_("malformed note - does not end with \\0"));
1153 return;
1154 }
1155
1156 ULONGEST count = bfd_get (addr_size_bits, core_bfd, descdata);
1157 descdata += addr_size;
1158
1159 ULONGEST page_size = bfd_get (addr_size_bits, core_bfd, descdata);
1160 descdata += addr_size;
1161
1162 if (note_size < 2 * addr_size + count * 3 * addr_size)
1163 {
1164 warning (_("malformed note - too short for supplied file count"));
1165 return;
1166 }
1167
1168 char *filenames = (char *) descdata + count * 3 * addr_size;
1169
1170 /* Make sure that the correct number of filenames exist. Complain
1171 if there aren't enough or are too many. */
1172 char *f = filenames;
1173 for (int i = 0; i < count; i++)
1174 {
1175 if (f >= descend)
1176 {
1177 warning (_("malformed note - filename area is too small"));
1178 return;
1179 }
1180 f += strnlen (f, descend - f) + 1;
1181 }
1182 /* Complain, but don't return early if the filename area is too big. */
1183 if (f != descend)
1184 warning (_("malformed note - filename area is too big"));
1185
1186 const bfd_build_id *orig_build_id = cbfd->build_id;
1187 std::unordered_map<ULONGEST, const bfd_build_id *> vma_map;
1188
1189 /* Search for solib build-ids in the core file. Each time one is found,
1190 map the start vma of the corresponding elf header to the build-id. */
1191 for (bfd_section *sec = cbfd->sections; sec != nullptr; sec = sec->next)
1192 {
1193 cbfd->build_id = nullptr;
1194
1195 if (sec->flags & SEC_LOAD
1196 && (get_elf_backend_data (cbfd)->elf_backend_core_find_build_id
1197 (cbfd, (bfd_vma) sec->filepos)))
1198 vma_map[sec->vma] = cbfd->build_id;
1199 }
1200
1201 cbfd->build_id = orig_build_id;
1202 pre_loop_cb (count);
1203
1204 for (int i = 0; i < count; i++)
1205 {
1206 ULONGEST start = bfd_get (addr_size_bits, core_bfd, descdata);
1207 descdata += addr_size;
1208 ULONGEST end = bfd_get (addr_size_bits, core_bfd, descdata);
1209 descdata += addr_size;
1210 ULONGEST file_ofs
1211 = bfd_get (addr_size_bits, core_bfd, descdata) * page_size;
1212 descdata += addr_size;
1213 char * filename = filenames;
1214 filenames += strlen ((char *) filenames) + 1;
1215 const bfd_build_id *build_id = nullptr;
1216 auto vma_map_it = vma_map.find (start);
1217
1218 if (vma_map_it != vma_map.end ())
1219 build_id = vma_map_it->second;
1220
1221 loop_cb (i, start, end, file_ofs, filename, build_id);
1222 }
1223}
1224
1225/* Implement "info proc mappings" for a corefile. */
1226
1227static void
1229{
1231 [=] (ULONGEST count)
1232 {
1233 gdb_printf (_("Mapped address spaces:\n\n"));
1234 if (gdbarch_addr_bit (gdbarch) == 32)
1235 {
1236 gdb_printf ("\t%10s %10s %10s %10s %s\n",
1237 "Start Addr",
1238 " End Addr",
1239 " Size", " Offset", "objfile");
1240 }
1241 else
1242 {
1243 gdb_printf (" %18s %18s %10s %10s %s\n",
1244 "Start Addr",
1245 " End Addr",
1246 " Size", " Offset", "objfile");
1247 }
1248 },
1249 [=] (int num, ULONGEST start, ULONGEST end, ULONGEST file_ofs,
1250 const char *filename, const bfd_build_id *build_id)
1251 {
1252 if (gdbarch_addr_bit (gdbarch) == 32)
1253 gdb_printf ("\t%10s %10s %10s %10s %s\n",
1254 paddress (gdbarch, start),
1255 paddress (gdbarch, end),
1256 hex_string (end - start),
1257 hex_string (file_ofs),
1258 filename);
1259 else
1260 gdb_printf (" %18s %18s %10s %10s %s\n",
1261 paddress (gdbarch, start),
1262 paddress (gdbarch, end),
1263 hex_string (end - start),
1264 hex_string (file_ofs),
1265 filename);
1266 });
1267}
1268
1269/* Implement "info proc" for a corefile. */
1270
1271static void
1272linux_core_info_proc (struct gdbarch *gdbarch, const char *args,
1273 enum info_proc_what what)
1274{
1275 int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
1276 int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
1277
1278 if (exe_f)
1279 {
1280 const char *exe;
1281
1282 exe = bfd_core_file_failing_command (core_bfd);
1283 if (exe != NULL)
1284 gdb_printf ("exe = '%s'\n", exe);
1285 else
1286 warning (_("unable to find command name in core file"));
1287 }
1288
1289 if (mappings_f)
1291
1292 if (!exe_f && !mappings_f)
1293 error (_("unable to handle request"));
1294}
1295
1296/* Read siginfo data from the core, if possible. Returns -1 on
1297 failure. Otherwise, returns the number of bytes read. READBUF,
1298 OFFSET, and LEN are all as specified by the to_xfer_partial
1299 interface. */
1300
1301static LONGEST
1302linux_core_xfer_siginfo (struct gdbarch *gdbarch, gdb_byte *readbuf,
1303 ULONGEST offset, ULONGEST len)
1304{
1305 thread_section_name section_name (".note.linuxcore.siginfo", inferior_ptid);
1306 asection *section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
1307 if (section == NULL)
1308 return -1;
1309
1310 if (!bfd_get_section_contents (core_bfd, section, readbuf, offset, len))
1311 return -1;
1312
1313 return len;
1314}
1315
1316typedef int linux_find_memory_region_ftype (ULONGEST vaddr, ULONGEST size,
1317 ULONGEST offset, ULONGEST inode,
1318 int read, int write,
1319 int exec, int modified,
1320 bool memory_tagged,
1321 const char *filename,
1322 void *data);
1323
1324typedef int linux_dump_mapping_p_ftype (filter_flags filterflags,
1325 const struct smaps_vmflags *v,
1326 int maybe_private_p,
1327 int mapping_anon_p,
1328 int mapping_file_p,
1329 const char *filename,
1330 ULONGEST addr,
1331 ULONGEST offset);
1332
1333/* Helper function to parse the contents of /proc/<pid>/smaps into a data
1334 structure, for easy access.
1335
1336 DATA is the contents of the smaps file. The parsed contents are stored
1337 into the SMAPS vector. */
1338
1339static std::vector<struct smaps_data>
1340parse_smaps_data (const char *data,
1341 const std::string maps_filename)
1342{
1343 char *line, *t;
1344
1345 gdb_assert (data != nullptr);
1346
1347 line = strtok_r ((char *) data, "\n", &t);
1348
1349 std::vector<struct smaps_data> smaps;
1350
1351 while (line != NULL)
1352 {
1353 struct smaps_vmflags v;
1354 int read, write, exec, priv;
1355 int has_anonymous = 0;
1356 int mapping_anon_p;
1357 int mapping_file_p;
1358
1359 memset (&v, 0, sizeof (v));
1360 struct mapping m = read_mapping (line);
1361 mapping_anon_p = mapping_is_anonymous_p (m.filename);
1362 /* If the mapping is not anonymous, then we can consider it
1363 to be file-backed. These two states (anonymous or
1364 file-backed) seem to be exclusive, but they can actually
1365 coexist. For example, if a file-backed mapping has
1366 "Anonymous:" pages (see more below), then the Linux
1367 kernel will dump this mapping when the user specified
1368 that she only wants anonymous mappings in the corefile
1369 (*even* when she explicitly disabled the dumping of
1370 file-backed mappings). */
1371 mapping_file_p = !mapping_anon_p;
1372
1373 /* Decode permissions. */
1374 auto has_perm = [&m] (char c)
1375 { return m.permissions.find (c) != gdb::string_view::npos; };
1376 read = has_perm ('r');
1377 write = has_perm ('w');
1378 exec = has_perm ('x');
1379
1380 /* 'private' here actually means VM_MAYSHARE, and not
1381 VM_SHARED. In order to know if a mapping is really
1382 private or not, we must check the flag "sh" in the
1383 VmFlags field. This is done by decode_vmflags. However,
1384 if we are using a Linux kernel released before the commit
1385 834f82e2aa9a8ede94b17b656329f850c1471514 (3.10), we will
1386 not have the VmFlags there. In this case, there is
1387 really no way to know if we are dealing with VM_SHARED,
1388 so we just assume that VM_MAYSHARE is enough. */
1389 priv = has_perm ('p');
1390
1391 /* Try to detect if region should be dumped by parsing smaps
1392 counters. */
1393 for (line = strtok_r (NULL, "\n", &t);
1394 line != NULL && line[0] >= 'A' && line[0] <= 'Z';
1395 line = strtok_r (NULL, "\n", &t))
1396 {
1397 char keyword[64 + 1];
1398
1399 if (sscanf (line, "%64s", keyword) != 1)
1400 {
1401 warning (_("Error parsing {s,}maps file '%s'"),
1402 maps_filename.c_str ());
1403 break;
1404 }
1405
1406 if (strcmp (keyword, "Anonymous:") == 0)
1407 {
1408 /* Older Linux kernels did not support the
1409 "Anonymous:" counter. Check it here. */
1410 has_anonymous = 1;
1411 }
1412 else if (strcmp (keyword, "VmFlags:") == 0)
1413 decode_vmflags (line, &v);
1414
1415 if (strcmp (keyword, "AnonHugePages:") == 0
1416 || strcmp (keyword, "Anonymous:") == 0)
1417 {
1418 unsigned long number;
1419
1420 if (sscanf (line, "%*s%lu", &number) != 1)
1421 {
1422 warning (_("Error parsing {s,}maps file '%s' number"),
1423 maps_filename.c_str ());
1424 break;
1425 }
1426 if (number > 0)
1427 {
1428 /* Even if we are dealing with a file-backed
1429 mapping, if it contains anonymous pages we
1430 consider it to be *also* an anonymous
1431 mapping, because this is what the Linux
1432 kernel does:
1433
1434 // Dump segments that have been written to.
1435 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1436 goto whole;
1437
1438 Note that if the mapping is already marked as
1439 file-backed (i.e., mapping_file_p is
1440 non-zero), then this is a special case, and
1441 this mapping will be dumped either when the
1442 user wants to dump file-backed *or* anonymous
1443 mappings. */
1444 mapping_anon_p = 1;
1445 }
1446 }
1447 }
1448 /* Save the smaps entry to the vector. */
1449 struct smaps_data map;
1450
1451 map.start_address = m.addr;
1452 map.end_address = m.endaddr;
1453 map.filename = m.filename;
1454 map.vmflags = v;
1455 map.read = read? true : false;
1456 map.write = write? true : false;
1457 map.exec = exec? true : false;
1458 map.priv = priv? true : false;
1460 map.mapping_anon_p = mapping_anon_p? true : false;
1461 map.mapping_file_p = mapping_file_p? true : false;
1462 map.offset = m.offset;
1463 map.inode = m.inode;
1464
1465 smaps.emplace_back (map);
1466 }
1467
1468 return smaps;
1469}
1470
1471/* Helper that checks if an address is in a memory tag page for a live
1472 process. */
1473
1474static bool
1476{
1477 if (current_inferior ()->fake_pid_p)
1478 return false;
1479
1480 pid_t pid = current_inferior ()->pid;
1481
1482 std::string smaps_file = string_printf ("/proc/%d/smaps", pid);
1483
1484 gdb::unique_xmalloc_ptr<char> data
1485 = target_fileio_read_stralloc (NULL, smaps_file.c_str ());
1486
1487 if (data == nullptr)
1488 return false;
1489
1490 /* Parse the contents of smaps into a vector. */
1491 std::vector<struct smaps_data> smaps
1492 = parse_smaps_data (data.get (), smaps_file);
1493
1494 for (const smaps_data &map : smaps)
1495 {
1496 /* Is the address within [start_address, end_address) in a page
1497 mapped with memory tagging? */
1498 if (address >= map.start_address
1499 && address < map.end_address
1500 && map.vmflags.memory_tagging)
1501 return true;
1502 }
1503
1504 return false;
1505}
1506
1507/* Helper that checks if an address is in a memory tag page for a core file
1508 process. */
1509
1510static bool
1512{
1513 if (core_bfd == nullptr)
1514 return false;
1515
1517 return get_next_core_memtag_section (core_bfd, nullptr, address, info);
1518}
1519
1520/* See linux-tdep.h. */
1521
1522bool
1524{
1525 if (!target_has_execution ())
1527
1528 return linux_process_address_in_memtag_page (address);
1529}
1530
1531/* List memory regions in the inferior for a corefile. */
1532
1533static int
1535 linux_dump_mapping_p_ftype *should_dump_mapping_p,
1537 void *obfd)
1538{
1539 pid_t pid;
1540 /* Default dump behavior of coredump_filter (0x33), according to
1541 Documentation/filesystems/proc.txt from the Linux kernel
1542 tree. */
1543 filter_flags filterflags = (COREFILTER_ANON_PRIVATE
1547
1548 /* We need to know the real target PID to access /proc. */
1550 return 1;
1551
1552 pid = current_inferior ()->pid;
1553
1555 {
1556 std::string core_dump_filter_name
1557 = string_printf ("/proc/%d/coredump_filter", pid);
1558
1559 gdb::unique_xmalloc_ptr<char> coredumpfilterdata
1560 = target_fileio_read_stralloc (NULL, core_dump_filter_name.c_str ());
1561
1562 if (coredumpfilterdata != NULL)
1563 {
1564 unsigned int flags;
1565
1566 sscanf (coredumpfilterdata.get (), "%x", &flags);
1567 filterflags = (enum filter_flag) flags;
1568 }
1569 }
1570
1571 std::string maps_filename = string_printf ("/proc/%d/smaps", pid);
1572
1573 gdb::unique_xmalloc_ptr<char> data
1574 = target_fileio_read_stralloc (NULL, maps_filename.c_str ());
1575
1576 if (data == NULL)
1577 {
1578 /* Older Linux kernels did not support /proc/PID/smaps. */
1579 maps_filename = string_printf ("/proc/%d/maps", pid);
1580 data = target_fileio_read_stralloc (NULL, maps_filename.c_str ());
1581
1582 if (data == nullptr)
1583 return 1;
1584 }
1585
1586 /* Parse the contents of smaps into a vector. */
1587 std::vector<struct smaps_data> smaps
1588 = parse_smaps_data (data.get (), maps_filename.c_str ());
1589
1590 for (const struct smaps_data &map : smaps)
1591 {
1592 int should_dump_p = 0;
1593
1594 if (map.has_anonymous)
1595 {
1596 should_dump_p
1597 = should_dump_mapping_p (filterflags, &map.vmflags,
1598 map.priv,
1599 map.mapping_anon_p,
1600 map.mapping_file_p,
1601 map.filename.c_str (),
1602 map.start_address,
1603 map.offset);
1604 }
1605 else
1606 {
1607 /* Older Linux kernels did not support the "Anonymous:" counter.
1608 If it is missing, we can't be sure - dump all the pages. */
1609 should_dump_p = 1;
1610 }
1611
1612 /* Invoke the callback function to create the corefile segment. */
1613 if (should_dump_p)
1614 {
1615 func (map.start_address, map.end_address - map.start_address,
1616 map.offset, map.inode, map.read, map.write, map.exec,
1617 1, /* MODIFIED is true because we want to dump
1618 the mapping. */
1619 map.vmflags.memory_tagging != 0,
1620 map.filename.c_str (), obfd);
1621 }
1622 }
1623
1624 return 0;
1625}
1626
1627/* A structure for passing information through
1628 linux_find_memory_regions_full. */
1629
1631{
1632 /* The original callback. */
1633
1635
1636 /* The original datum. */
1637
1638 void *obfd;
1639};
1640
1641/* A callback for linux_find_memory_regions that converts between the
1642 "full"-style callback and find_memory_region_ftype. */
1643
1644static int
1645linux_find_memory_regions_thunk (ULONGEST vaddr, ULONGEST size,
1646 ULONGEST offset, ULONGEST inode,
1647 int read, int write, int exec, int modified,
1648 bool memory_tagged,
1649 const char *filename, void *arg)
1650{
1652 = (struct linux_find_memory_regions_data *) arg;
1653
1654 return data->func (vaddr, size, read, write, exec, modified, memory_tagged,
1655 data->obfd);
1656}
1657
1658/* A variant of linux_find_memory_regions_full that is suitable as the
1659 gdbarch find_memory_regions method. */
1660
1661static int
1664{
1666
1667 data.func = func;
1668 data.obfd = obfd;
1669
1673 &data);
1674}
1675
1676/* This is used to pass information from
1677 linux_make_mappings_corefile_notes through
1678 linux_find_memory_regions_full. */
1679
1681{
1682 /* Number of files mapped. */
1683 ULONGEST file_count;
1684
1685 /* The obstack for the main part of the data. */
1686 struct obstack *data_obstack;
1687
1688 /* The filename obstack. */
1689 struct obstack *filename_obstack;
1690
1691 /* The architecture's "long" type. */
1693};
1694
1696
1697/* A callback for linux_find_memory_regions_full that updates the
1698 mappings data for linux_make_mappings_corefile_notes.
1699
1700 MEMORY_TAGGED is true if the memory region contains memory tags, false
1701 otherwise. */
1702
1703static int
1704linux_make_mappings_callback (ULONGEST vaddr, ULONGEST size,
1705 ULONGEST offset, ULONGEST inode,
1706 int read, int write, int exec, int modified,
1707 bool memory_tagged,
1708 const char *filename, void *data)
1709{
1710 struct linux_make_mappings_data *map_data
1711 = (struct linux_make_mappings_data *) data;
1712 gdb_byte buf[sizeof (ULONGEST)];
1713
1714 if (*filename == '\0' || inode == 0)
1715 return 0;
1716
1717 ++map_data->file_count;
1718
1719 pack_long (buf, map_data->long_type, vaddr);
1720 obstack_grow (map_data->data_obstack, buf, map_data->long_type->length ());
1721 pack_long (buf, map_data->long_type, vaddr + size);
1722 obstack_grow (map_data->data_obstack, buf, map_data->long_type->length ());
1723 pack_long (buf, map_data->long_type, offset);
1724 obstack_grow (map_data->data_obstack, buf, map_data->long_type->length ());
1725
1726 obstack_grow_str0 (map_data->filename_obstack, filename);
1727
1728 return 0;
1729}
1730
1731/* Write the file mapping data to the core file, if possible. OBFD is
1732 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
1733 is a pointer to the note size. Updates NOTE_DATA and NOTE_SIZE. */
1734
1735static void
1737 gdb::unique_xmalloc_ptr<char> &note_data,
1738 int *note_size)
1739{
1740 struct linux_make_mappings_data mapping_data;
1741 struct type *long_type
1743 gdb_byte buf[sizeof (ULONGEST)];
1744
1745 auto_obstack data_obstack, filename_obstack;
1746
1747 mapping_data.file_count = 0;
1748 mapping_data.data_obstack = &data_obstack;
1749 mapping_data.filename_obstack = &filename_obstack;
1750 mapping_data.long_type = long_type;
1751
1752 /* Reserve space for the count. */
1753 obstack_blank (&data_obstack, long_type->length ());
1754 /* We always write the page size as 1 since we have no good way to
1755 determine the correct value. */
1756 pack_long (buf, long_type, 1);
1757 obstack_grow (&data_obstack, buf, long_type->length ());
1758
1762 &mapping_data);
1763
1764 if (mapping_data.file_count != 0)
1765 {
1766 /* Write the count to the obstack. */
1767 pack_long ((gdb_byte *) obstack_base (&data_obstack),
1768 long_type, mapping_data.file_count);
1769
1770 /* Copy the filenames to the data obstack. */
1771 int size = obstack_object_size (&filename_obstack);
1772 obstack_grow (&data_obstack, obstack_base (&filename_obstack),
1773 size);
1774
1775 note_data.reset (elfcore_write_file_note (obfd, note_data.release (), note_size,
1776 obstack_base (&data_obstack),
1777 obstack_object_size (&data_obstack)));
1778 }
1779}
1780
1781/* Fetch the siginfo data for the specified thread, if it exists. If
1782 there is no data, or we could not read it, return an empty
1783 buffer. */
1784
1785static gdb::byte_vector
1787{
1788 struct type *siginfo_type;
1789 LONGEST bytes_read;
1790
1792 return gdb::byte_vector ();
1793
1794 scoped_restore_current_thread save_current_thread;
1795 switch_to_thread (thread);
1796
1797 siginfo_type = gdbarch_get_siginfo_type (gdbarch);
1798
1799 gdb::byte_vector buf (siginfo_type->length ());
1800
1801 bytes_read = target_read (current_inferior ()->top_target (),
1803 buf.data (), 0, siginfo_type->length ());
1804 if (bytes_read != siginfo_type->length ())
1805 buf.clear ();
1806
1807 return buf;
1808}
1809
1811{
1813 gdb::unique_xmalloc_ptr<char> &note_data,
1814 int *note_size, gdb_signal stop_signal)
1817 {}
1818
1820 bfd *obfd;
1821 gdb::unique_xmalloc_ptr<char> &note_data;
1823 enum gdb_signal stop_signal;
1824};
1825
1826/* Records the thread's register state for the corefile note
1827 section. */
1828
1829static void
1831 struct linux_corefile_thread_data *args)
1832{
1834 args->stop_signal,
1835 args->obfd, &args->note_data,
1836 args->note_size);
1837
1838 /* Don't return anything if we got no register information above,
1839 such a core file is useless. */
1840 if (args->note_data != NULL)
1841 {
1842 gdb::byte_vector siginfo_data
1843 = linux_get_siginfo_data (info, args->gdbarch);
1844 if (!siginfo_data.empty ())
1845 args->note_data.reset (elfcore_write_note (args->obfd,
1846 args->note_data.release (),
1847 args->note_size,
1848 "CORE", NT_SIGINFO,
1849 siginfo_data.data (),
1850 siginfo_data.size ()));
1851 }
1852}
1853
1854/* Fill the PRPSINFO structure with information about the process being
1855 debugged. Returns 1 in case of success, 0 for failures. Please note that
1856 even if the structure cannot be entirely filled (e.g., GDB was unable to
1857 gather information about the process UID/GID), this function will still
1858 return 1 since some information was already recorded. It will only return
1859 0 iff nothing can be gathered. */
1860
1861static int
1862linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo *p)
1863{
1864 /* The filename which we will use to obtain some info about the process.
1865 We will basically use this to store the `/proc/PID/FILENAME' file. */
1866 char filename[100];
1867 /* The basename of the executable. */
1868 const char *basename;
1869 /* Temporary buffer. */
1870 char *tmpstr;
1871 /* The valid states of a process, according to the Linux kernel. */
1872 const char valid_states[] = "RSDTZW";
1873 /* The program state. */
1874 const char *prog_state;
1875 /* The state of the process. */
1876 char pr_sname;
1877 /* The PID of the program which generated the corefile. */
1878 pid_t pid;
1879 /* Process flags. */
1880 unsigned int pr_flag;
1881 /* Process nice value. */
1882 long pr_nice;
1883 /* The number of fields read by `sscanf'. */
1884 int n_fields = 0;
1885
1886 gdb_assert (p != NULL);
1887
1888 /* Obtaining PID and filename. */
1889 pid = inferior_ptid.pid ();
1890 xsnprintf (filename, sizeof (filename), "/proc/%d/cmdline", (int) pid);
1891 /* The full name of the program which generated the corefile. */
1892 gdb::unique_xmalloc_ptr<char> fname
1893 = target_fileio_read_stralloc (NULL, filename);
1894
1895 if (fname == NULL || fname.get ()[0] == '\0')
1896 {
1897 /* No program name was read, so we won't be able to retrieve more
1898 information about the process. */
1899 return 0;
1900 }
1901
1902 memset (p, 0, sizeof (*p));
1903
1904 /* Defining the PID. */
1905 p->pr_pid = pid;
1906
1907 /* Copying the program name. Only the basename matters. */
1908 basename = lbasename (fname.get ());
1909 strncpy (p->pr_fname, basename, sizeof (p->pr_fname) - 1);
1910 p->pr_fname[sizeof (p->pr_fname) - 1] = '\0';
1911
1912 const std::string &infargs = current_inferior ()->args ();
1913
1914 /* The arguments of the program. */
1915 std::string psargs = fname.get ();
1916 if (!infargs.empty ())
1917 psargs += ' ' + infargs;
1918
1919 strncpy (p->pr_psargs, psargs.c_str (), sizeof (p->pr_psargs) - 1);
1920 p->pr_psargs[sizeof (p->pr_psargs) - 1] = '\0';
1921
1922 xsnprintf (filename, sizeof (filename), "/proc/%d/stat", (int) pid);
1923 /* The contents of `/proc/PID/stat'. */
1924 gdb::unique_xmalloc_ptr<char> proc_stat_contents
1925 = target_fileio_read_stralloc (NULL, filename);
1926 char *proc_stat = proc_stat_contents.get ();
1927
1928 if (proc_stat == NULL || *proc_stat == '\0')
1929 {
1930 /* Despite being unable to read more information about the
1931 process, we return 1 here because at least we have its
1932 command line, PID and arguments. */
1933 return 1;
1934 }
1935
1936 /* Ok, we have the stats. It's time to do a little parsing of the
1937 contents of the buffer, so that we end up reading what we want.
1938
1939 The following parsing mechanism is strongly based on the
1940 information generated by the `fs/proc/array.c' file, present in
1941 the Linux kernel tree. More details about how the information is
1942 displayed can be obtained by seeing the manpage of proc(5),
1943 specifically under the entry of `/proc/[pid]/stat'. */
1944
1945 /* Getting rid of the PID, since we already have it. */
1946 while (isdigit (*proc_stat))
1947 ++proc_stat;
1948
1949 proc_stat = skip_spaces (proc_stat);
1950
1951 /* ps command also relies on no trailing fields ever contain ')'. */
1952 proc_stat = strrchr (proc_stat, ')');
1953 if (proc_stat == NULL)
1954 return 1;
1955 proc_stat++;
1956
1957 proc_stat = skip_spaces (proc_stat);
1958
1959 n_fields = sscanf (proc_stat,
1960 "%c" /* Process state. */
1961 "%d%d%d" /* Parent PID, group ID, session ID. */
1962 "%*d%*d" /* tty_nr, tpgid (not used). */
1963 "%u" /* Flags. */
1964 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1965 cmajflt (not used). */
1966 "%*s%*s%*s%*s" /* utime, stime, cutime,
1967 cstime (not used). */
1968 "%*s" /* Priority (not used). */
1969 "%ld", /* Nice. */
1970 &pr_sname,
1971 &p->pr_ppid, &p->pr_pgrp, &p->pr_sid,
1972 &pr_flag,
1973 &pr_nice);
1974
1975 if (n_fields != 6)
1976 {
1977 /* Again, we couldn't read the complementary information about
1978 the process state. However, we already have minimal
1979 information, so we just return 1 here. */
1980 return 1;
1981 }
1982
1983 /* Filling the structure fields. */
1984 prog_state = strchr (valid_states, pr_sname);
1985 if (prog_state != NULL)
1986 p->pr_state = prog_state - valid_states;
1987 else
1988 {
1989 /* Zero means "Running". */
1990 p->pr_state = 0;
1991 }
1992
1993 p->pr_sname = p->pr_state > 5 ? '.' : pr_sname;
1994 p->pr_zomb = p->pr_sname == 'Z';
1995 p->pr_nice = pr_nice;
1996 p->pr_flag = pr_flag;
1997
1998 /* Finally, obtaining the UID and GID. For that, we read and parse the
1999 contents of the `/proc/PID/status' file. */
2000 xsnprintf (filename, sizeof (filename), "/proc/%d/status", (int) pid);
2001 /* The contents of `/proc/PID/status'. */
2002 gdb::unique_xmalloc_ptr<char> proc_status_contents
2003 = target_fileio_read_stralloc (NULL, filename);
2004 char *proc_status = proc_status_contents.get ();
2005
2006 if (proc_status == NULL || *proc_status == '\0')
2007 {
2008 /* Returning 1 since we already have a bunch of information. */
2009 return 1;
2010 }
2011
2012 /* Extracting the UID. */
2013 tmpstr = strstr (proc_status, "Uid:");
2014 if (tmpstr != NULL)
2015 {
2016 /* Advancing the pointer to the beginning of the UID. */
2017 tmpstr += sizeof ("Uid:");
2018 while (*tmpstr != '\0' && !isdigit (*tmpstr))
2019 ++tmpstr;
2020
2021 if (isdigit (*tmpstr))
2022 p->pr_uid = strtol (tmpstr, &tmpstr, 10);
2023 }
2024
2025 /* Extracting the GID. */
2026 tmpstr = strstr (proc_status, "Gid:");
2027 if (tmpstr != NULL)
2028 {
2029 /* Advancing the pointer to the beginning of the GID. */
2030 tmpstr += sizeof ("Gid:");
2031 while (*tmpstr != '\0' && !isdigit (*tmpstr))
2032 ++tmpstr;
2033
2034 if (isdigit (*tmpstr))
2035 p->pr_gid = strtol (tmpstr, &tmpstr, 10);
2036 }
2037
2038 return 1;
2039}
2040
2041/* Build the note section for a corefile, and return it in a malloc
2042 buffer. */
2043
2044static gdb::unique_xmalloc_ptr<char>
2046{
2047 struct elf_internal_linux_prpsinfo prpsinfo;
2048 gdb::unique_xmalloc_ptr<char> note_data;
2049
2051 return NULL;
2052
2053 if (linux_fill_prpsinfo (&prpsinfo))
2054 {
2055 if (gdbarch_ptr_bit (gdbarch) == 64)
2056 note_data.reset (elfcore_write_linux_prpsinfo64 (obfd,
2057 note_data.release (),
2058 note_size, &prpsinfo));
2059 else
2060 note_data.reset (elfcore_write_linux_prpsinfo32 (obfd,
2061 note_data.release (),
2062 note_size, &prpsinfo));
2063 }
2064
2065 /* Thread register information. */
2066 try
2067 {
2069 }
2070 catch (const gdb_exception_error &e)
2071 {
2073 }
2074
2075 /* Like the kernel, prefer dumping the signalled thread first.
2076 "First thread" is what tools use to infer the signalled
2077 thread. */
2078 thread_info *signalled_thr = gcore_find_signalled_thread ();
2079 gdb_signal stop_signal;
2080 if (signalled_thr != nullptr)
2081 stop_signal = signalled_thr->stop_signal ();
2082 else
2083 stop_signal = GDB_SIGNAL_0;
2084
2085 linux_corefile_thread_data thread_args (gdbarch, obfd, note_data, note_size,
2086 stop_signal);
2087
2088 if (signalled_thr != nullptr)
2089 linux_corefile_thread (signalled_thr, &thread_args);
2090 for (thread_info *thr : current_inferior ()->non_exited_threads ())
2091 {
2092 if (thr == signalled_thr)
2093 continue;
2094
2095 linux_corefile_thread (thr, &thread_args);
2096 }
2097
2098 if (!note_data)
2099 return NULL;
2100
2101 /* Auxillary vector. */
2102 gdb::optional<gdb::byte_vector> auxv =
2103 target_read_alloc (current_inferior ()->top_target (),
2104 TARGET_OBJECT_AUXV, NULL);
2105 if (auxv && !auxv->empty ())
2106 {
2107 note_data.reset (elfcore_write_note (obfd, note_data.release (),
2108 note_size, "CORE", NT_AUXV,
2109 auxv->data (), auxv->size ()));
2110
2111 if (!note_data)
2112 return NULL;
2113 }
2114
2115 /* File mappings. */
2117
2118 /* Target description. */
2120
2121 return note_data;
2122}
2123
2124/* Implementation of `gdbarch_gdb_signal_from_target', as defined in
2125 gdbarch.h. This function is not static because it is exported to
2126 other -tdep files. */
2127
2128enum gdb_signal
2130{
2131 switch (signal)
2132 {
2133 case 0:
2134 return GDB_SIGNAL_0;
2135
2136 case LINUX_SIGHUP:
2137 return GDB_SIGNAL_HUP;
2138
2139 case LINUX_SIGINT:
2140 return GDB_SIGNAL_INT;
2141
2142 case LINUX_SIGQUIT:
2143 return GDB_SIGNAL_QUIT;
2144
2145 case LINUX_SIGILL:
2146 return GDB_SIGNAL_ILL;
2147
2148 case LINUX_SIGTRAP:
2149 return GDB_SIGNAL_TRAP;
2150
2151 case LINUX_SIGABRT:
2152 return GDB_SIGNAL_ABRT;
2153
2154 case LINUX_SIGBUS:
2155 return GDB_SIGNAL_BUS;
2156
2157 case LINUX_SIGFPE:
2158 return GDB_SIGNAL_FPE;
2159
2160 case LINUX_SIGKILL:
2161 return GDB_SIGNAL_KILL;
2162
2163 case LINUX_SIGUSR1:
2164 return GDB_SIGNAL_USR1;
2165
2166 case LINUX_SIGSEGV:
2167 return GDB_SIGNAL_SEGV;
2168
2169 case LINUX_SIGUSR2:
2170 return GDB_SIGNAL_USR2;
2171
2172 case LINUX_SIGPIPE:
2173 return GDB_SIGNAL_PIPE;
2174
2175 case LINUX_SIGALRM:
2176 return GDB_SIGNAL_ALRM;
2177
2178 case LINUX_SIGTERM:
2179 return GDB_SIGNAL_TERM;
2180
2181 case LINUX_SIGCHLD:
2182 return GDB_SIGNAL_CHLD;
2183
2184 case LINUX_SIGCONT:
2185 return GDB_SIGNAL_CONT;
2186
2187 case LINUX_SIGSTOP:
2188 return GDB_SIGNAL_STOP;
2189
2190 case LINUX_SIGTSTP:
2191 return GDB_SIGNAL_TSTP;
2192
2193 case LINUX_SIGTTIN:
2194 return GDB_SIGNAL_TTIN;
2195
2196 case LINUX_SIGTTOU:
2197 return GDB_SIGNAL_TTOU;
2198
2199 case LINUX_SIGURG:
2200 return GDB_SIGNAL_URG;
2201
2202 case LINUX_SIGXCPU:
2203 return GDB_SIGNAL_XCPU;
2204
2205 case LINUX_SIGXFSZ:
2206 return GDB_SIGNAL_XFSZ;
2207
2208 case LINUX_SIGVTALRM:
2209 return GDB_SIGNAL_VTALRM;
2210
2211 case LINUX_SIGPROF:
2212 return GDB_SIGNAL_PROF;
2213
2214 case LINUX_SIGWINCH:
2215 return GDB_SIGNAL_WINCH;
2216
2217 /* No way to differentiate between SIGIO and SIGPOLL.
2218 Therefore, we just handle the first one. */
2219 case LINUX_SIGIO:
2220 return GDB_SIGNAL_IO;
2221
2222 case LINUX_SIGPWR:
2223 return GDB_SIGNAL_PWR;
2224
2225 case LINUX_SIGSYS:
2226 return GDB_SIGNAL_SYS;
2227
2228 /* SIGRTMIN and SIGRTMAX are not continuous in <gdb/signals.def>,
2229 therefore we have to handle them here. */
2230 case LINUX_SIGRTMIN:
2231 return GDB_SIGNAL_REALTIME_32;
2232
2233 case LINUX_SIGRTMAX:
2234 return GDB_SIGNAL_REALTIME_64;
2235 }
2236
2237 if (signal >= LINUX_SIGRTMIN + 1 && signal <= LINUX_SIGRTMAX - 1)
2238 {
2239 int offset = signal - LINUX_SIGRTMIN + 1;
2240
2241 return (enum gdb_signal) ((int) GDB_SIGNAL_REALTIME_33 + offset);
2242 }
2243
2244 return GDB_SIGNAL_UNKNOWN;
2245}
2246
2247/* Implementation of `gdbarch_gdb_signal_to_target', as defined in
2248 gdbarch.h. This function is not static because it is exported to
2249 other -tdep files. */
2250
2251int
2253 enum gdb_signal signal)
2254{
2255 switch (signal)
2256 {
2257 case GDB_SIGNAL_0:
2258 return 0;
2259
2260 case GDB_SIGNAL_HUP:
2261 return LINUX_SIGHUP;
2262
2263 case GDB_SIGNAL_INT:
2264 return LINUX_SIGINT;
2265
2266 case GDB_SIGNAL_QUIT:
2267 return LINUX_SIGQUIT;
2268
2269 case GDB_SIGNAL_ILL:
2270 return LINUX_SIGILL;
2271
2272 case GDB_SIGNAL_TRAP:
2273 return LINUX_SIGTRAP;
2274
2275 case GDB_SIGNAL_ABRT:
2276 return LINUX_SIGABRT;
2277
2278 case GDB_SIGNAL_FPE:
2279 return LINUX_SIGFPE;
2280
2281 case GDB_SIGNAL_KILL:
2282 return LINUX_SIGKILL;
2283
2284 case GDB_SIGNAL_BUS:
2285 return LINUX_SIGBUS;
2286
2287 case GDB_SIGNAL_SEGV:
2288 return LINUX_SIGSEGV;
2289
2290 case GDB_SIGNAL_SYS:
2291 return LINUX_SIGSYS;
2292
2293 case GDB_SIGNAL_PIPE:
2294 return LINUX_SIGPIPE;
2295
2296 case GDB_SIGNAL_ALRM:
2297 return LINUX_SIGALRM;
2298
2299 case GDB_SIGNAL_TERM:
2300 return LINUX_SIGTERM;
2301
2302 case GDB_SIGNAL_URG:
2303 return LINUX_SIGURG;
2304
2305 case GDB_SIGNAL_STOP:
2306 return LINUX_SIGSTOP;
2307
2308 case GDB_SIGNAL_TSTP:
2309 return LINUX_SIGTSTP;
2310
2311 case GDB_SIGNAL_CONT:
2312 return LINUX_SIGCONT;
2313
2314 case GDB_SIGNAL_CHLD:
2315 return LINUX_SIGCHLD;
2316
2317 case GDB_SIGNAL_TTIN:
2318 return LINUX_SIGTTIN;
2319
2320 case GDB_SIGNAL_TTOU:
2321 return LINUX_SIGTTOU;
2322
2323 case GDB_SIGNAL_IO:
2324 return LINUX_SIGIO;
2325
2326 case GDB_SIGNAL_XCPU:
2327 return LINUX_SIGXCPU;
2328
2329 case GDB_SIGNAL_XFSZ:
2330 return LINUX_SIGXFSZ;
2331
2332 case GDB_SIGNAL_VTALRM:
2333 return LINUX_SIGVTALRM;
2334
2335 case GDB_SIGNAL_PROF:
2336 return LINUX_SIGPROF;
2337
2338 case GDB_SIGNAL_WINCH:
2339 return LINUX_SIGWINCH;
2340
2341 case GDB_SIGNAL_USR1:
2342 return LINUX_SIGUSR1;
2343
2344 case GDB_SIGNAL_USR2:
2345 return LINUX_SIGUSR2;
2346
2347 case GDB_SIGNAL_PWR:
2348 return LINUX_SIGPWR;
2349
2350 case GDB_SIGNAL_POLL:
2351 return LINUX_SIGPOLL;
2352
2353 /* GDB_SIGNAL_REALTIME_32 is not continuous in <gdb/signals.def>,
2354 therefore we have to handle it here. */
2355 case GDB_SIGNAL_REALTIME_32:
2356 return LINUX_SIGRTMIN;
2357
2358 /* Same comment applies to _64. */
2359 case GDB_SIGNAL_REALTIME_64:
2360 return LINUX_SIGRTMAX;
2361 }
2362
2363 /* GDB_SIGNAL_REALTIME_33 to _64 are continuous. */
2364 if (signal >= GDB_SIGNAL_REALTIME_33
2365 && signal <= GDB_SIGNAL_REALTIME_63)
2366 {
2367 int offset = signal - GDB_SIGNAL_REALTIME_33;
2368
2369 return LINUX_SIGRTMIN + 1 + offset;
2370 }
2371
2372 return -1;
2373}
2374
2375/* Helper for linux_vsyscall_range that does the real work of finding
2376 the vsyscall's address range. */
2377
2378static int
2380{
2381 char filename[100];
2382 long pid;
2383
2384 if (target_auxv_search (AT_SYSINFO_EHDR, &range->start) <= 0)
2385 return 0;
2386
2387 /* It doesn't make sense to access the host's /proc when debugging a
2388 core file. Instead, look for the PT_LOAD segment that matches
2389 the vDSO. */
2390 if (!target_has_execution ())
2391 {
2392 long phdrs_size;
2393 int num_phdrs, i;
2394
2395 phdrs_size = bfd_get_elf_phdr_upper_bound (core_bfd);
2396 if (phdrs_size == -1)
2397 return 0;
2398
2399 gdb::unique_xmalloc_ptr<Elf_Internal_Phdr>
2400 phdrs ((Elf_Internal_Phdr *) xmalloc (phdrs_size));
2401 num_phdrs = bfd_get_elf_phdrs (core_bfd, phdrs.get ());
2402 if (num_phdrs == -1)
2403 return 0;
2404
2405 for (i = 0; i < num_phdrs; i++)
2406 if (phdrs.get ()[i].p_type == PT_LOAD
2407 && phdrs.get ()[i].p_vaddr == range->start)
2408 {
2409 range->length = phdrs.get ()[i].p_memsz;
2410 return 1;
2411 }
2412
2413 return 0;
2414 }
2415
2416 /* We need to know the real target PID to access /proc. */
2417 if (current_inferior ()->fake_pid_p)
2418 return 0;
2419
2420 pid = current_inferior ()->pid;
2421
2422 /* Note that reading /proc/PID/task/PID/maps (1) is much faster than
2423 reading /proc/PID/maps (2). The later identifies thread stacks
2424 in the output, which requires scanning every thread in the thread
2425 group to check whether a VMA is actually a thread's stack. With
2426 Linux 4.4 on an Intel i7-4810MQ @ 2.80GHz, with an inferior with
2427 a few thousand threads, (1) takes a few miliseconds, while (2)
2428 takes several seconds. Also note that "smaps", what we read for
2429 determining core dump mappings, is even slower than "maps". */
2430 xsnprintf (filename, sizeof filename, "/proc/%ld/task/%ld/maps", pid, pid);
2431 gdb::unique_xmalloc_ptr<char> data
2432 = target_fileio_read_stralloc (NULL, filename);
2433 if (data != NULL)
2434 {
2435 char *line;
2436 char *saveptr = NULL;
2437
2438 for (line = strtok_r (data.get (), "\n", &saveptr);
2439 line != NULL;
2440 line = strtok_r (NULL, "\n", &saveptr))
2441 {
2442 ULONGEST addr, endaddr;
2443 const char *p = line;
2444
2445 addr = strtoulst (p, &p, 16);
2446 if (addr == range->start)
2447 {
2448 if (*p == '-')
2449 p++;
2450 endaddr = strtoulst (p, &p, 16);
2451 range->length = endaddr - addr;
2452 return 1;
2453 }
2454 }
2455 }
2456 else
2457 warning (_("unable to open /proc file '%s'"), filename);
2458
2459 return 0;
2460}
2461
2462/* Implementation of the "vsyscall_range" gdbarch hook. Handles
2463 caching, and defers the real work to linux_vsyscall_range_raw. */
2464
2465static int
2467{
2469
2470 if (info->vsyscall_range_p == 0)
2471 {
2472 if (linux_vsyscall_range_raw (gdbarch, &info->vsyscall_range))
2473 info->vsyscall_range_p = 1;
2474 else
2475 info->vsyscall_range_p = -1;
2476 }
2477
2478 if (info->vsyscall_range_p < 0)
2479 return 0;
2480
2481 *range = info->vsyscall_range;
2482 return 1;
2483}
2484
2485/* Symbols for linux_infcall_mmap's ARG_FLAGS; their Linux MAP_* system
2486 definitions would be dependent on compilation host. */
2487#define GDB_MMAP_MAP_PRIVATE 0x02 /* Changes are private. */
2488#define GDB_MMAP_MAP_ANONYMOUS 0x20 /* Don't use a file. */
2489
2490/* See gdbarch.sh 'infcall_mmap'. */
2491
2492static CORE_ADDR
2493linux_infcall_mmap (CORE_ADDR size, unsigned prot)
2494{
2495 struct objfile *objf;
2496 /* Do there still exist any Linux systems without "mmap64"?
2497 "mmap" uses 64-bit off_t on x86_64 and 32-bit off_t on i386 and x32. */
2498 struct value *mmap_val = find_function_in_inferior ("mmap64", &objf);
2499 struct value *addr_val;
2500 struct gdbarch *gdbarch = objf->arch ();
2501 CORE_ADDR retval;
2502 enum
2503 {
2504 ARG_ADDR, ARG_LENGTH, ARG_PROT, ARG_FLAGS, ARG_FD, ARG_OFFSET, ARG_LAST
2505 };
2506 struct value *arg[ARG_LAST];
2507
2508 arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2509 0);
2510 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2511 arg[ARG_LENGTH] = value_from_ulongest
2512 (builtin_type (gdbarch)->builtin_unsigned_long, size);
2513 gdb_assert ((prot & ~(GDB_MMAP_PROT_READ | GDB_MMAP_PROT_WRITE
2515 == 0);
2516 arg[ARG_PROT] = value_from_longest (builtin_type (gdbarch)->builtin_int, prot);
2517 arg[ARG_FLAGS] = value_from_longest (builtin_type (gdbarch)->builtin_int,
2520 arg[ARG_FD] = value_from_longest (builtin_type (gdbarch)->builtin_int, -1);
2521 arg[ARG_OFFSET] = value_from_longest (builtin_type (gdbarch)->builtin_int64,
2522 0);
2523 addr_val = call_function_by_hand (mmap_val, NULL, arg);
2524 retval = value_as_address (addr_val);
2525 if (retval == (CORE_ADDR) -1)
2526 error (_("Failed inferior mmap call for %s bytes, errno is changed."),
2527 pulongest (size));
2528 return retval;
2529}
2530
2531/* See gdbarch.sh 'infcall_munmap'. */
2532
2533static void
2534linux_infcall_munmap (CORE_ADDR addr, CORE_ADDR size)
2535{
2536 struct objfile *objf;
2537 struct value *munmap_val = find_function_in_inferior ("munmap", &objf);
2538 struct value *retval_val;
2539 struct gdbarch *gdbarch = objf->arch ();
2540 LONGEST retval;
2541 enum
2542 {
2543 ARG_ADDR, ARG_LENGTH, ARG_LAST
2544 };
2545 struct value *arg[ARG_LAST];
2546
2547 arg[ARG_ADDR] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr,
2548 addr);
2549 /* Assuming sizeof (unsigned long) == sizeof (size_t). */
2550 arg[ARG_LENGTH] = value_from_ulongest
2551 (builtin_type (gdbarch)->builtin_unsigned_long, size);
2552 retval_val = call_function_by_hand (munmap_val, NULL, arg);
2553 retval = value_as_long (retval_val);
2554 if (retval != 0)
2555 warning (_("Failed inferior munmap call at %s for %s bytes, "
2556 "errno is changed."),
2557 hex_string (addr), pulongest (size));
2558}
2559
2560/* See linux-tdep.h. */
2561
2562CORE_ADDR
2564{
2565 CORE_ADDR addr;
2566 int bp_len;
2567
2568 /* Determine entry point from target auxiliary vector. This avoids
2569 the need for symbols. Also, when debugging a stand-alone SPU
2570 executable, entry_point_address () will point to an SPU
2571 local-store address and is thus not usable as displaced stepping
2572 location. The auxiliary vector gets us the PowerPC-side entry
2573 point address instead. */
2574 if (target_auxv_search (AT_ENTRY, &addr) <= 0)
2575 throw_error (NOT_SUPPORTED_ERROR,
2576 _("Cannot find AT_ENTRY auxiliary vector entry."));
2577
2578 /* Make certain that the address points at real code, and not a
2579 function descriptor. */
2581 (gdbarch, addr, current_inferior ()->top_target ());
2582
2583 /* Inferior calls also use the entry point as a breakpoint location.
2584 We don't want displaced stepping to interfere with those
2585 breakpoints, so leave space. */
2586 gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
2587 addr += bp_len * 2;
2588
2589 return addr;
2590}
2591
2592/* See linux-tdep.h. */
2593
2596 CORE_ADDR &displaced_pc)
2597{
2598 linux_info *per_inferior = get_linux_inferior_data (thread->inf);
2599
2600 if (!per_inferior->disp_step_bufs.has_value ())
2601 {
2602 /* Figure out the location of the buffers. They are contiguous, starting
2603 at DISP_STEP_BUF_ADDR. They are all of size BUF_LEN. */
2604 CORE_ADDR disp_step_buf_addr
2606 int buf_len = gdbarch_max_insn_length (arch);
2607
2608 linux_gdbarch_data *gdbarch_data = get_linux_gdbarch_data (arch);
2609 gdb_assert (gdbarch_data->num_disp_step_buffers > 0);
2610
2611 std::vector<CORE_ADDR> buffers;
2612 for (int i = 0; i < gdbarch_data->num_disp_step_buffers; i++)
2613 buffers.push_back (disp_step_buf_addr + i * buf_len);
2614
2615 per_inferior->disp_step_bufs.emplace (buffers);
2616 }
2617
2618 return per_inferior->disp_step_bufs->prepare (thread, displaced_pc);
2619}
2620
2621/* See linux-tdep.h. */
2622
2624linux_displaced_step_finish (gdbarch *arch, thread_info *thread, gdb_signal sig)
2625{
2626 linux_info *per_inferior = get_linux_inferior_data (thread->inf);
2627
2628 gdb_assert (per_inferior->disp_step_bufs.has_value ());
2629
2630 return per_inferior->disp_step_bufs->finish (arch, thread, sig);
2631}
2632
2633/* See linux-tdep.h. */
2634
2637{
2638 linux_info *per_inferior = linux_inferior_data.get (inf);
2639
2640 if (per_inferior == nullptr
2641 || !per_inferior->disp_step_bufs.has_value ())
2642 return nullptr;
2643
2644 return per_inferior->disp_step_bufs->copy_insn_closure_by_addr (addr);
2645}
2646
2647/* See linux-tdep.h. */
2648
2649void
2651{
2652 linux_info *per_inferior = linux_inferior_data.get (parent_inf);
2653
2654 if (per_inferior == nullptr
2655 || !per_inferior->disp_step_bufs.has_value ())
2656 return;
2657
2658 per_inferior->disp_step_bufs->restore_in_ptid (ptid);
2659}
2660
2661/* Helper for linux_get_hwcap and linux_get_hwcap2. */
2662
2663static CORE_ADDR
2664linux_get_hwcap_helper (const gdb::optional<gdb::byte_vector> &auxv,
2665 target_ops *target, gdbarch *gdbarch, CORE_ADDR match)
2666{
2667 CORE_ADDR field;
2668 if (!auxv.has_value ()
2669 || target_auxv_search (*auxv, target, gdbarch, match, &field) != 1)
2670 return 0;
2671 return field;
2672}
2673
2674/* See linux-tdep.h. */
2675
2676CORE_ADDR
2677linux_get_hwcap (const gdb::optional<gdb::byte_vector> &auxv,
2678 target_ops *target, gdbarch *gdbarch)
2679{
2680 return linux_get_hwcap_helper (auxv, target, gdbarch, AT_HWCAP);
2681}
2682
2683/* See linux-tdep.h. */
2684
2685CORE_ADDR
2687{
2689 current_inferior ()->top_target (),
2691}
2692
2693/* See linux-tdep.h. */
2694
2695CORE_ADDR
2696linux_get_hwcap2 (const gdb::optional<gdb::byte_vector> &auxv,
2697 target_ops *target, gdbarch *gdbarch)
2698{
2699 return linux_get_hwcap_helper (auxv, target, gdbarch, AT_HWCAP2);
2700}
2701
2702/* See linux-tdep.h. */
2703
2704CORE_ADDR
2706{
2708 current_inferior ()->top_target (),
2710}
2711
2712/* Display whether the gcore command is using the
2713 /proc/PID/coredump_filter file. */
2714
2715static void
2716show_use_coredump_filter (struct ui_file *file, int from_tty,
2717 struct cmd_list_element *c, const char *value)
2718{
2719 gdb_printf (file, _("Use of /proc/PID/coredump_filter file to generate"
2720 " corefiles is %s.\n"), value);
2721}
2722
2723/* Display whether the gcore command is dumping mappings marked with
2724 the VM_DONTDUMP flag. */
2725
2726static void
2727show_dump_excluded_mappings (struct ui_file *file, int from_tty,
2728 struct cmd_list_element *c, const char *value)
2729{
2730 gdb_printf (file, _("Dumping of mappings marked with the VM_DONTDUMP"
2731 " flag is %s.\n"), value);
2732}
2733
2734/* To be called from the various GDB_OSABI_LINUX handlers for the
2735 various GNU/Linux architectures and machine types.
2736
2737 NUM_DISP_STEP_BUFFERS is the number of displaced step buffers to use. If 0,
2738 displaced stepping is not supported. */
2739
2740void
2742 int num_disp_step_buffers)
2743{
2744 if (num_disp_step_buffers > 0)
2745 {
2747 gdbarch_data->num_disp_step_buffers = num_disp_step_buffers;
2748
2756 }
2757
2775}
2776
2778void
2780{
2781 /* Observers used to invalidate the cache when needed. */
2783 "linux-tdep");
2785 "linux-tdep");
2787 "linux-tdep");
2788
2789 add_setshow_boolean_cmd ("use-coredump-filter", class_files,
2790 &use_coredump_filter, _("\
2791Set whether gcore should consider /proc/PID/coredump_filter."),
2792 _("\
2793Show whether gcore should consider /proc/PID/coredump_filter."),
2794 _("\
2795Use this command to set whether gcore should consider the contents\n\
2796of /proc/PID/coredump_filter when generating the corefile. For more information\n\
2797about this file, refer to the manpage of core(5)."),
2799 &setlist, &showlist);
2800
2801 add_setshow_boolean_cmd ("dump-excluded-mappings", class_files,
2803Set whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2804 _("\
2805Show whether gcore should dump mappings marked with the VM_DONTDUMP flag."),
2806 _("\
2807Use this command to set whether gcore should dump mappings marked with the\n\
2808VM_DONTDUMP flag (\"dd\" in /proc/PID/smaps) when generating the corefile. For\n\
2809more information about this file, refer to the manpage of proc(5) and core(5)."),
2811 &setlist, &showlist);
2812}
2813
2814/* Fetch (and possibly build) an appropriate `link_map_offsets' for
2815 ILP32/LP64 Linux systems which don't have the r_ldsomap field. */
2816
2819{
2820 static link_map_offsets lmo;
2821 static link_map_offsets *lmp = nullptr;
2822
2823 if (lmp == nullptr)
2824 {
2825 lmp = &lmo;
2826
2827 lmo.r_version_offset = 0;
2828 lmo.r_version_size = 4;
2829 lmo.r_map_offset = 4;
2830 lmo.r_brk_offset = 8;
2831 lmo.r_ldsomap_offset = -1;
2832 lmo.r_next_offset = 20;
2833
2834 /* Everything we need is in the first 20 bytes. */
2835 lmo.link_map_size = 20;
2836 lmo.l_addr_offset = 0;
2837 lmo.l_name_offset = 4;
2838 lmo.l_ld_offset = 8;
2839 lmo.l_next_offset = 12;
2840 lmo.l_prev_offset = 16;
2841 }
2842
2843 return lmp;
2844}
2845
2848{
2849 static link_map_offsets lmo;
2850 static link_map_offsets *lmp = nullptr;
2851
2852 if (lmp == nullptr)
2853 {
2854 lmp = &lmo;
2855
2856 lmo.r_version_offset = 0;
2857 lmo.r_version_size = 4;
2858 lmo.r_map_offset = 8;
2859 lmo.r_brk_offset = 16;
2860 lmo.r_ldsomap_offset = -1;
2861 lmo.r_next_offset = 40;
2862
2863 /* Everything we need is in the first 40 bytes. */
2864 lmo.link_map_size = 40;
2865 lmo.l_addr_offset = 0;
2866 lmo.l_name_offset = 8;
2867 lmo.l_ld_offset = 16;
2868 lmo.l_next_offset = 24;
2869 lmo.l_prev_offset = 32;
2870 }
2871
2872 return lmp;
2873}
void * xmalloc(YYSIZE_T)
if(!(yy_init))
Definition: ada-lex.c:1109
gdb_static_assert(sizeof(splay_tree_key) >=sizeof(CORE_ADDR *))
#define GDB_MMAP_PROT_WRITE
Definition: arch-utils.h:267
#define GDB_MMAP_PROT_EXEC
Definition: arch-utils.h:268
#define GDB_MMAP_PROT_READ
Definition: arch-utils.h:266
int target_auxv_search(const gdb::byte_vector &auxv, target_ops *ops, gdbarch *gdbarch, CORE_ADDR match, CORE_ADDR *valp)
Definition: auxv.c:383
gdb::optional< gdb::byte_vector > target_read_auxv()
Definition: auxv.c:358
void f()
Definition: 1.cc:36
int pid
Definition: inferior.h:526
bool fake_pid_p
Definition: inferior.h:528
const std::string & args() const
Definition: inferior.h:498
struct gdbarch * gdbarch
Definition: inferior.h:626
void * get(unsigned key)
Definition: registry.h:211
gdb_signal stop_signal() const
Definition: gdbthread.h:421
struct inferior * inf
Definition: gdbthread.h:298
const char * c_str() const
Definition: gdbcore.h:194
struct cmd_list_element * showlist
Definition: cli-cmds.c:125
struct cmd_list_element * setlist
Definition: cli-cmds.c:117
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:739
@ class_files
Definition: command.h:57
info_proc_what
Definition: defs.h:381
@ IP_CMDLINE
Definition: defs.h:395
@ IP_EXE
Definition: defs.h:398
@ IP_ALL
Definition: defs.h:407
@ IP_MAPPINGS
Definition: defs.h:386
@ IP_STATUS
Definition: defs.h:389
@ IP_MINIMAL
Definition: defs.h:383
@ IP_CWD
Definition: defs.h:401
@ IP_STAT
Definition: defs.h:392
int(* find_memory_region_ftype)(CORE_ADDR addr, unsigned long size, int read, int write, int exec, int modified, bool memory_tagged, void *data)
Definition: defs.h:351
displaced_step_prepare_status
displaced_step_finish_status
void exception_print(struct ui_file *file, const struct gdb_exception &e)
Definition: exceptions.c:105
ssize_t read(int fd, void *buf, size_t count)
Definition: expect-read1.c:26
void gcore_elf_make_tdesc_note(bfd *obfd, gdb::unique_xmalloc_ptr< char > *note_data, int *note_size)
Definition: gcore-elf.c:142
void gcore_elf_build_thread_register_notes(struct gdbarch *gdbarch, struct thread_info *info, gdb_signal stop_signal, bfd *obfd, gdb::unique_xmalloc_ptr< char > *note_data, int *note_size)
Definition: gcore-elf.c:128
thread_info * gcore_find_signalled_thread()
Definition: gcore.c:669
const gdb_byte * gdbarch_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
Definition: gdbarch.c:2712
void set_gdbarch_displaced_step_restore_all_in_ptid(struct gdbarch *gdbarch, gdbarch_displaced_step_restore_all_in_ptid_ftype *displaced_step_restore_all_in_ptid)
void set_gdbarch_find_memory_regions(struct gdbarch *gdbarch, gdbarch_find_memory_regions_ftype *find_memory_regions)
void set_gdbarch_displaced_step_finish(struct gdbarch *gdbarch, gdbarch_displaced_step_finish_ftype *displaced_step_finish)
void set_gdbarch_displaced_step_prepare(struct gdbarch *gdbarch, gdbarch_displaced_step_prepare_ftype *displaced_step_prepare)
void set_gdbarch_infcall_mmap(struct gdbarch *gdbarch, gdbarch_infcall_mmap_ftype *infcall_mmap)
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1708
bool gdbarch_get_siginfo_type_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4344
bfd int * note_size
Definition: gdbarch-gen.h:894
void set_gdbarch_core_info_proc(struct gdbarch *gdbarch, gdbarch_core_info_proc_ftype *core_info_proc)
bfd * obfd
Definition: gdbarch-gen.h:894
void set_gdbarch_core_xfer_siginfo(struct gdbarch *gdbarch, gdbarch_core_xfer_siginfo_ftype *core_xfer_siginfo)
void set_gdbarch_vsyscall_range(struct gdbarch *gdbarch, gdbarch_vsyscall_range_ftype *vsyscall_range)
void set_gdbarch_get_siginfo_type(struct gdbarch *gdbarch, gdbarch_get_siginfo_type_ftype *get_siginfo_type)
int gdbarch_int_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1423
void set_gdbarch_read_core_file_mappings(struct gdbarch *gdbarch, gdbarch_read_core_file_mappings_ftype *read_core_file_mappings)
void set_gdbarch_infcall_munmap(struct gdbarch *gdbarch, gdbarch_infcall_munmap_ftype *infcall_munmap)
void set_gdbarch_gdb_signal_from_target(struct gdbarch *gdbarch, gdbarch_gdb_signal_from_target_ftype *gdb_signal_from_target)
void set_gdbarch_core_pid_to_str(struct gdbarch *gdbarch, gdbarch_core_pid_to_str_ftype *core_pid_to_str)
void set_gdbarch_gdb_signal_to_target(struct gdbarch *gdbarch, gdbarch_gdb_signal_to_target_ftype *gdb_signal_to_target)
bool gdbarch_iterate_over_regset_sections_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3645
void set_gdbarch_make_corefile_notes(struct gdbarch *gdbarch, gdbarch_make_corefile_notes_ftype *make_corefile_notes)
void set_gdbarch_has_shared_address_space(struct gdbarch *gdbarch, gdbarch_has_shared_address_space_ftype *has_shared_address_space)
void set_gdbarch_displaced_step_copy_insn_closure_by_addr(struct gdbarch *gdbarch, gdbarch_displaced_step_copy_insn_closure_by_addr_ftype *displaced_step_copy_insn_closure_by_addr)
void set_gdbarch_info_proc(struct gdbarch *gdbarch, gdbarch_info_proc_ftype *info_proc)
struct type * gdbarch_get_siginfo_type(struct gdbarch *gdbarch)
Definition: gdbarch.c:4351
int gdbarch_long_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1440
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition: gdbarch.c:3070
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1691
ULONGEST gdbarch_max_insn_length(struct gdbarch *gdbarch)
Definition: gdbarch.c:3992
gdb::function_view< void(int num, ULONGEST start, ULONGEST end, ULONGEST file_ofs, const char *filename, const bfd_build_id *build_id)> read_core_file_mappings_loop_ftype
Definition: gdbarch.h:150
gdb::function_view< void(ULONGEST count)> read_core_file_mappings_pre_loop_ftype
Definition: gdbarch.h:142
#define core_bfd
Definition: gdbcore.h:130
void update_thread_list(void)
Definition: thread.c:2037
void switch_to_thread(struct thread_info *thr)
Definition: thread.c:1335
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:402
struct type * arch_composite_type(struct gdbarch *gdbarch, const char *name, enum type_code code)
Definition: gdbtypes.c:5989
struct type * init_vector_type(struct type *elt_type, int n)
Definition: gdbtypes.c:1540
struct type * arch_type(struct gdbarch *gdbarch, enum type_code code, int bit, const char *name)
Definition: gdbtypes.c:5815
void append_composite_type_field_aligned(struct type *t, const char *name, struct type *field, int alignment)
Definition: gdbtypes.c:6025
void append_composite_type_field(struct type *t, const char *name, struct type *field)
Definition: gdbtypes.c:6065
struct type * arch_integer_type(struct gdbarch *gdbarch, int bit, int unsigned_p, const char *name)
Definition: gdbtypes.c:5836
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1862
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1792
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition: gnu-nat.c:1791
unsigned dummy
Definition: go32-nat.c:8
size_t size
Definition: go32-nat.c:241
struct value * call_function_by_hand(struct value *function, type *default_return_type, gdb::array_view< value * > args)
Definition: infcall.c:781
ptid_t inferior_ptid
Definition: infcmd.c:91
struct inferior * current_inferior(void)
Definition: inferior.c:54
link_map_offsets * linux_lp64_fetch_link_map_offsets()
Definition: linux-tdep.c:2847
displaced_step_prepare_status linux_displaced_step_prepare(gdbarch *arch, thread_info *thread, CORE_ADDR &displaced_pc)
Definition: linux-tdep.c:2595
static CORE_ADDR linux_infcall_mmap(CORE_ADDR size, unsigned prot)
Definition: linux-tdep.c:2493
static void show_dump_excluded_mappings(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: linux-tdep.c:2727
static std::vector< struct smaps_data > parse_smaps_data(const char *data, const std::string maps_filename)
Definition: linux-tdep.c:1340
int linux_find_memory_region_ftype(ULONGEST vaddr, ULONGEST size, ULONGEST offset, ULONGEST inode, int read, int write, int exec, int modified, bool memory_tagged, const char *filename, void *data)
Definition: linux-tdep.c:1316
filter_flag
Definition: linux-tdep.c:57
@ COREFILTER_MAPPED_PRIVATE
Definition: linux-tdep.c:60
@ COREFILTER_ANON_PRIVATE
Definition: linux-tdep.c:58
@ COREFILTER_MAPPED_SHARED
Definition: linux-tdep.c:61
@ COREFILTER_ANON_SHARED
Definition: linux-tdep.c:59
@ COREFILTER_HUGETLB_SHARED
Definition: linux-tdep.c:64
@ COREFILTER_HUGETLB_PRIVATE
Definition: linux-tdep.c:63
@ COREFILTER_ELF_HEADERS
Definition: linux-tdep.c:62
static const registry< gdbarch >::key< linux_gdbarch_data > linux_gdbarch_data_handle
Definition: linux-tdep.c:203
static gdb::unique_xmalloc_ptr< char > linux_make_corefile_notes(struct gdbarch *gdbarch, bfd *obfd, int *note_size)
Definition: linux-tdep.c:2045
static int dump_mapping_p(filter_flags filterflags, const struct smaps_vmflags *v, int maybe_private_p, int mapping_anon_p, int mapping_file_p, const char *filename, ULONGEST addr, ULONGEST offset)
Definition: linux-tdep.c:667
DEF_ENUM_FLAGS_TYPE(enum filter_flag, filter_flags)
static int linux_fill_prpsinfo(struct elf_internal_linux_prpsinfo *p)
Definition: linux-tdep.c:1862
static struct linux_info * get_linux_inferior_data(inferior *inf)
Definition: linux-tdep.c:251
void linux_displaced_step_restore_all_in_ptid(inferior *parent_inf, ptid_t ptid)
Definition: linux-tdep.c:2650
static int linux_vsyscall_range_raw(struct gdbarch *gdbarch, struct mem_range *range)
Definition: linux-tdep.c:2379
int linux_gdb_signal_to_target(struct gdbarch *gdbarch, enum gdb_signal signal)
Definition: linux-tdep.c:2252
static std::string linux_core_pid_to_str(struct gdbarch *gdbarch, ptid_t ptid)
Definition: linux-tdep.c:434
static void linux_corefile_thread(struct thread_info *info, struct linux_corefile_thread_data *args)
Definition: linux-tdep.c:1830
static mapping read_mapping(const char *line)
Definition: linux-tdep.c:461
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:2716
static bool linux_core_file_address_in_memtag_page(CORE_ADDR address)
Definition: linux-tdep.c:1511
enum gdb_signal linux_gdb_signal_from_target(struct gdbarch *gdbarch, int signal)
Definition: linux-tdep.c:2129
static LONGEST linux_core_xfer_siginfo(struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len)
Definition: linux-tdep.c:1302
static int linux_find_memory_regions_thunk(ULONGEST vaddr, ULONGEST size, ULONGEST offset, ULONGEST inode, int read, int write, int exec, int modified, bool memory_tagged, const char *filename, void *arg)
Definition: linux-tdep.c:1645
static bool use_coredump_filter
Definition: linux-tdep.c:124
CORE_ADDR linux_displaced_step_location(struct gdbarch *gdbarch)
Definition: linux-tdep.c:2563
static int linux_find_memory_regions_full(struct gdbarch *gdbarch, linux_dump_mapping_p_ftype *should_dump_mapping_p, linux_find_memory_region_ftype *func, void *obfd)
Definition: linux-tdep.c:1534
static int linux_has_shared_address_space(struct gdbarch *gdbarch)
Definition: linux-tdep.c:426
#define SELFMAG
static bool dump_excluded_mappings
Definition: linux-tdep.c:129
link_map_offsets * linux_ilp32_fetch_link_map_offsets()
Definition: linux-tdep.c:2818
static int linux_vsyscall_range(struct gdbarch *gdbarch, struct mem_range *range)
Definition: linux-tdep.c:2466
static void linux_info_proc(struct gdbarch *gdbarch, const char *args, enum info_proc_what what)
Definition: linux-tdep.c:802
CORE_ADDR linux_get_hwcap2()
Definition: linux-tdep.c:2705
void linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch, int num_disp_step_buffers)
Definition: linux-tdep.c:2741
bool linux_address_in_memtag_page(CORE_ADDR address)
Definition: linux-tdep.c:1523
static void linux_make_mappings_corefile_notes(struct gdbarch *gdbarch, bfd *obfd, gdb::unique_xmalloc_ptr< char > &note_data, int *note_size)
Definition: linux-tdep.c:1736
#define GDB_MMAP_MAP_ANONYMOUS
Definition: linux-tdep.c:2488
#define GDB_MMAP_MAP_PRIVATE
Definition: linux-tdep.c:2487
static struct type * linux_get_siginfo_type(struct gdbarch *gdbarch)
Definition: linux-tdep.c:408
static linux_find_memory_region_ftype linux_make_mappings_callback
Definition: linux-tdep.c:1695
int linux_dump_mapping_p_ftype(filter_flags filterflags, const struct smaps_vmflags *v, int maybe_private_p, int mapping_anon_p, int mapping_file_p, const char *filename, ULONGEST addr, ULONGEST offset)
Definition: linux-tdep.c:1324
static int mapping_is_anonymous_p(const char *filename)
Definition: linux-tdep.c:578
@ LINUX_SIGKILL
Definition: linux-tdep.c:166
@ LINUX_SIGSYS
Definition: linux-tdep.c:189
@ LINUX_SIGINT
Definition: linux-tdep.c:158
@ LINUX_SIGXFSZ
Definition: linux-tdep.c:182
@ LINUX_SIGTSTP
Definition: linux-tdep.c:177
@ LINUX_SIGBUS
Definition: linux-tdep.c:164
@ LINUX_SIGTTOU
Definition: linux-tdep.c:179
@ LINUX_SIGPWR
Definition: linux-tdep.c:188
@ LINUX_SIGQUIT
Definition: linux-tdep.c:159
@ LINUX_SIGCONT
Definition: linux-tdep.c:175
@ LINUX_SIGTERM
Definition: linux-tdep.c:172
@ LINUX_SIGRTMIN
Definition: linux-tdep.c:192
@ LINUX_SIGHUP
Definition: linux-tdep.c:157
@ LINUX_SIGWINCH
Definition: linux-tdep.c:185
@ LINUX_SIGTRAP
Definition: linux-tdep.c:161
@ LINUX_SIGXCPU
Definition: linux-tdep.c:181
@ LINUX_SIGFPE
Definition: linux-tdep.c:165
@ LINUX_SIGSTOP
Definition: linux-tdep.c:176
@ LINUX_SIGABRT
Definition: linux-tdep.c:162
@ LINUX_SIGTTIN
Definition: linux-tdep.c:178
@ LINUX_SIGALRM
Definition: linux-tdep.c:171
@ LINUX_SIGUNUSED
Definition: linux-tdep.c:190
@ LINUX_SIGPROF
Definition: linux-tdep.c:184
@ LINUX_SIGSTKFLT
Definition: linux-tdep.c:173
@ LINUX_SIGIO
Definition: linux-tdep.c:186
@ LINUX_SIGIOT
Definition: linux-tdep.c:163
@ LINUX_SIGSEGV
Definition: linux-tdep.c:168
@ LINUX_SIGRTMAX
Definition: linux-tdep.c:193
@ LINUX_SIGPOLL
Definition: linux-tdep.c:187
@ LINUX_SIGILL
Definition: linux-tdep.c:160
@ LINUX_SIGURG
Definition: linux-tdep.c:180
@ LINUX_SIGUSR2
Definition: linux-tdep.c:169
@ LINUX_SIGUSR1
Definition: linux-tdep.c:167
@ LINUX_SIGPIPE
Definition: linux-tdep.c:170
@ LINUX_SIGVTALRM
Definition: linux-tdep.c:183
@ LINUX_SIGCHLD
Definition: linux-tdep.c:174
static struct linux_gdbarch_data * get_linux_gdbarch_data(struct gdbarch *gdbarch)
Definition: linux-tdep.c:206
const displaced_step_copy_insn_closure * linux_displaced_step_copy_insn_closure_by_addr(inferior *inf, CORE_ADDR addr)
Definition: linux-tdep.c:2636
int linux_is_uclinux(void)
Definition: linux-tdep.c:417
static int dump_note_entry_p(filter_flags filterflags, const struct smaps_vmflags *v, int maybe_private_p, int mapping_anon_p, int mapping_file_p, const char *filename, ULONGEST addr, ULONGEST offset)
Definition: linux-tdep.c:784
CORE_ADDR linux_get_hwcap()
Definition: linux-tdep.c:2686
static CORE_ADDR linux_get_hwcap_helper(const gdb::optional< gdb::byte_vector > &auxv, target_ops *target, gdbarch *gdbarch, CORE_ADDR match)
Definition: linux-tdep.c:2664
static void decode_vmflags(char *p, struct smaps_vmflags *v)
Definition: linux-tdep.c:503
displaced_step_finish_status linux_displaced_step_finish(gdbarch *arch, thread_info *thread, gdb_signal sig)
Definition: linux-tdep.c:2624
static void linux_core_info_proc_mappings(struct gdbarch *gdbarch, const char *args)
Definition: linux-tdep.c:1228
static const registry< inferior >::key< linux_info > linux_inferior_data
Definition: linux-tdep.c:236
struct type * linux_get_siginfo_type_with_fields(struct gdbarch *gdbarch, linux_siginfo_extra_fields extra_fields)
Definition: linux-tdep.c:264
static int linux_find_memory_regions(struct gdbarch *gdbarch, find_memory_region_ftype func, void *obfd)
Definition: linux-tdep.c:1662
static bool linux_process_address_in_memtag_page(CORE_ADDR address)
Definition: linux-tdep.c:1475
static void linux_infcall_munmap(CORE_ADDR addr, CORE_ADDR size)
Definition: linux-tdep.c:2534
static void linux_core_info_proc(struct gdbarch *gdbarch, const char *args, enum info_proc_what what)
Definition: linux-tdep.c:1272
static gdb::byte_vector linux_get_siginfo_data(thread_info *thread, struct gdbarch *gdbarch)
Definition: linux-tdep.c:1786
void _initialize_linux_tdep()
Definition: linux-tdep.c:2779
static void invalidate_linux_cache_inf(struct inferior *inf)
Definition: linux-tdep.c:242
static void linux_read_core_file_mappings(struct gdbarch *gdbarch, struct bfd *cbfd, read_core_file_mappings_pre_loop_ftype pre_loop_cb, read_core_file_mappings_loop_ftype loop_cb)
Definition: linux-tdep.c:1114
@ LINUX_SIGINFO_FIELD_ADDR_BND
Definition: linux-tdep.h:34
bool get_next_core_memtag_section(bfd *abfd, asection *section, CORE_ADDR address, memtag_section_info &info)
Definition: memtag.c:27
observable< struct inferior * > inferior_exit
observable< struct inferior * > inferior_execd
observable< struct inferior * > inferior_appeared
def info(c)
Definition: gdbarch.py:184
void(* func)(remote_target *remote, char *)
Definition: gnu-nat.c:154
gdb::unique_xmalloc_ptr< char > & note_data
Definition: linux-tdep.c:1821
struct gdbarch * gdbarch
Definition: linux-tdep.c:1819
linux_corefile_thread_data(struct gdbarch *gdbarch, bfd *obfd, gdb::unique_xmalloc_ptr< char > &note_data, int *note_size, gdb_signal stop_signal)
Definition: linux-tdep.c:1812
enum gdb_signal stop_signal
Definition: linux-tdep.c:1823
find_memory_region_ftype func
Definition: linux-tdep.c:1634
struct type * siginfo_type
Definition: linux-tdep.c:198
int vsyscall_range_p
Definition: linux-tdep.c:229
gdb::optional< displaced_step_buffers > disp_step_bufs
Definition: linux-tdep.c:232
struct type * long_type
Definition: linux-tdep.c:1692
struct obstack * filename_obstack
Definition: linux-tdep.c:1689
struct obstack * data_obstack
Definition: linux-tdep.c:1686
compiled_regex file_deleted
Definition: linux-tdep.c:563
compiled_regex dev_zero
Definition: linux-tdep.c:539
compiled_regex shmem_file
Definition: linux-tdep.c:547
gdb::string_view device
Definition: linux-tdep.c:450
ULONGEST addr
Definition: linux-tdep.c:446
gdb::string_view permissions
Definition: linux-tdep.c:448
ULONGEST endaddr
Definition: linux-tdep.c:447
const char * filename
Definition: linux-tdep.c:455
ULONGEST offset
Definition: linux-tdep.c:449
ULONGEST inode
Definition: linux-tdep.c:451
struct gdbarch * arch() const
Definition: objfiles.h:482
Definition: value.c:72
LONGEST length
Definition: value.c:77
bool mapping_anon_p
Definition: linux-tdep.c:114
struct smaps_vmflags vmflags
Definition: linux-tdep.c:108
bool write
Definition: linux-tdep.c:110
bool mapping_file_p
Definition: linux-tdep.c:115
bool has_anonymous
Definition: linux-tdep.c:113
ULONGEST start_address
Definition: linux-tdep.c:105
ULONGEST offset
Definition: linux-tdep.c:118
ULONGEST end_address
Definition: linux-tdep.c:106
std::string filename
Definition: linux-tdep.c:107
ULONGEST inode
Definition: linux-tdep.c:117
unsigned int io_page
Definition: linux-tdep.c:81
unsigned int initialized_p
Definition: linux-tdep.c:77
unsigned int shared_mapping
Definition: linux-tdep.c:93
unsigned int uses_huge_tlb
Definition: linux-tdep.c:85
unsigned int exclude_coredump
Definition: linux-tdep.c:89
unsigned int memory_tagging
Definition: linux-tdep.c:97
Definition: gdbtypes.h:922
ULONGEST length() const
Definition: gdbtypes.h:954
void set_target_type(struct type *target_type)
Definition: gdbtypes.h:1005
void set_name(const char *name)
Definition: gdbtypes.h:945
void set_target_is_stub(bool target_is_stub)
Definition: gdbtypes.h:1112
Definition: value.c:181
gdb::unique_xmalloc_ptr< char > target_fileio_read_stralloc(struct inferior *inf, const char *filename)
Definition: target.c:3529
LONGEST target_fileio_read_alloc(struct inferior *inf, const char *filename, gdb_byte **buf_p)
Definition: target.c:3520
bool target_has_execution(inferior *inf)
Definition: target.c:202
gdb::optional< gdb::byte_vector > target_read_alloc(struct target_ops *ops, enum target_object object, const char *annex)
Definition: target.c:2298
LONGEST target_read(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *buf, ULONGEST offset, LONGEST len)
Definition: target.c:1956
std::string normal_pid_to_str(ptid_t ptid)
Definition: target.c:3672
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1771
gdb::optional< std::string > target_fileio_readlink(struct inferior *inf, const char *filename, fileio_error *target_errno)
Definition: target.c:3400
@ TARGET_OBJECT_AUXV
Definition: target.h:157
@ TARGET_OBJECT_SIGNAL_INFO
Definition: target.h:182
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:3114
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition: utils.c:1865
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:1788
#define gdb_stderr
Definition: utils.h:193
struct value * find_function_in_inferior(const char *name, struct objfile **objf_p)
Definition: valops.c:117
CORE_ADDR value_as_address(struct value *val)
Definition: value.c:2804
struct value * value_from_ulongest(struct type *type, ULONGEST num)
Definition: value.c:3637
struct value * value_from_longest(struct type *type, LONGEST num)
Definition: value.c:3625
LONGEST value_as_long(struct value *val)
Definition: value.c:2791
void pack_long(gdb_byte *buf, struct type *type, LONGEST num)
Definition: value.c:3513
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
Definition: value.c:3651