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