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