1 /* Target-dependent code for GNU/Linux, architecture independent.
3 Copyright (C) 2009-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
22 #include "linux-tdep.h"
25 #include "gdbthread.h"
29 #include "elf/common.h"
30 #include "elf-bfd.h" /* for elfcore_write_* */
32 #include "cli/cli-utils.h"
33 #include "arch-utils.h"
34 #include "gdb_obstack.h"
35 #include "cli/cli-utils.h"
39 static struct gdbarch_data *linux_gdbarch_data_handle;
41 struct linux_gdbarch_data
43 struct type *siginfo_type;
47 init_linux_gdbarch_data (struct gdbarch *gdbarch)
49 return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct linux_gdbarch_data);
52 static struct linux_gdbarch_data *
53 get_linux_gdbarch_data (struct gdbarch *gdbarch)
55 return gdbarch_data (gdbarch, linux_gdbarch_data_handle);
58 /* This function is suitable for architectures that don't
59 extend/override the standard siginfo structure. */
62 linux_get_siginfo_type (struct gdbarch *gdbarch)
64 struct linux_gdbarch_data *linux_gdbarch_data;
65 struct type *int_type, *uint_type, *long_type, *void_ptr_type;
66 struct type *uid_type, *pid_type;
67 struct type *sigval_type, *clock_type;
68 struct type *siginfo_type, *sifields_type;
71 linux_gdbarch_data = get_linux_gdbarch_data (gdbarch);
72 if (linux_gdbarch_data->siginfo_type != NULL)
73 return linux_gdbarch_data->siginfo_type;
75 int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
77 uint_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
79 long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
81 void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
84 sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
85 TYPE_NAME (sigval_type) = xstrdup ("sigval_t");
86 append_composite_type_field (sigval_type, "sival_int", int_type);
87 append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
90 pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
91 TYPE_LENGTH (int_type), "__pid_t");
92 TYPE_TARGET_TYPE (pid_type) = int_type;
93 TYPE_TARGET_STUB (pid_type) = 1;
96 uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
97 TYPE_LENGTH (uint_type), "__uid_t");
98 TYPE_TARGET_TYPE (uid_type) = uint_type;
99 TYPE_TARGET_STUB (uid_type) = 1;
102 clock_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
103 TYPE_LENGTH (long_type), "__clock_t");
104 TYPE_TARGET_TYPE (clock_type) = long_type;
105 TYPE_TARGET_STUB (clock_type) = 1;
108 sifields_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
111 const int si_max_size = 128;
113 int size_of_int = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
116 if (gdbarch_ptr_bit (gdbarch) == 64)
117 si_pad_size = (si_max_size / size_of_int) - 4;
119 si_pad_size = (si_max_size / size_of_int) - 3;
120 append_composite_type_field (sifields_type, "_pad",
121 init_vector_type (int_type, si_pad_size));
125 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
126 append_composite_type_field (type, "si_pid", pid_type);
127 append_composite_type_field (type, "si_uid", uid_type);
128 append_composite_type_field (sifields_type, "_kill", type);
131 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
132 append_composite_type_field (type, "si_tid", int_type);
133 append_composite_type_field (type, "si_overrun", int_type);
134 append_composite_type_field (type, "si_sigval", sigval_type);
135 append_composite_type_field (sifields_type, "_timer", type);
138 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
139 append_composite_type_field (type, "si_pid", pid_type);
140 append_composite_type_field (type, "si_uid", uid_type);
141 append_composite_type_field (type, "si_sigval", sigval_type);
142 append_composite_type_field (sifields_type, "_rt", type);
145 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
146 append_composite_type_field (type, "si_pid", pid_type);
147 append_composite_type_field (type, "si_uid", uid_type);
148 append_composite_type_field (type, "si_status", int_type);
149 append_composite_type_field (type, "si_utime", clock_type);
150 append_composite_type_field (type, "si_stime", clock_type);
151 append_composite_type_field (sifields_type, "_sigchld", type);
154 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
155 append_composite_type_field (type, "si_addr", void_ptr_type);
156 append_composite_type_field (sifields_type, "_sigfault", type);
159 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
160 append_composite_type_field (type, "si_band", long_type);
161 append_composite_type_field (type, "si_fd", int_type);
162 append_composite_type_field (sifields_type, "_sigpoll", type);
165 siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
166 TYPE_NAME (siginfo_type) = xstrdup ("siginfo");
167 append_composite_type_field (siginfo_type, "si_signo", int_type);
168 append_composite_type_field (siginfo_type, "si_errno", int_type);
169 append_composite_type_field (siginfo_type, "si_code", int_type);
170 append_composite_type_field_aligned (siginfo_type,
171 "_sifields", sifields_type,
172 TYPE_LENGTH (long_type));
174 linux_gdbarch_data->siginfo_type = siginfo_type;
180 linux_has_shared_address_space (struct gdbarch *gdbarch)
182 /* Determine whether we are running on uClinux or normal Linux
185 int target_is_uclinux;
188 = (target_auxv_search (¤t_target, AT_NULL, &dummy) > 0
189 && target_auxv_search (¤t_target, AT_PAGESZ, &dummy) == 0);
191 return target_is_uclinux;
194 /* This is how we want PTIDs from core files to be printed. */
197 linux_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
201 if (ptid_get_lwp (ptid) != 0)
203 snprintf (buf, sizeof (buf), "LWP %ld", ptid_get_lwp (ptid));
207 return normal_pid_to_str (ptid);
210 /* Service function for corefiles and info proc. */
213 read_mapping (const char *line,
214 ULONGEST *addr, ULONGEST *endaddr,
215 const char **permissions, size_t *permissions_len,
217 const char **device, size_t *device_len,
219 const char **filename)
221 const char *p = line;
223 *addr = strtoulst (p, &p, 16);
226 *endaddr = strtoulst (p, &p, 16);
228 while (*p && isspace (*p))
231 while (*p && !isspace (*p))
233 *permissions_len = p - *permissions;
235 *offset = strtoulst (p, &p, 16);
237 while (*p && isspace (*p))
240 while (*p && !isspace (*p))
242 *device_len = p - *device;
244 *inode = strtoulst (p, &p, 10);
246 while (*p && isspace (*p))
251 /* Implement the "info proc" command. */
254 linux_info_proc (struct gdbarch *gdbarch, char *args,
255 enum info_proc_what what)
257 /* A long is used for pid instead of an int to avoid a loss of precision
258 compiler warning from the output of strtoul. */
260 int cmdline_f = (what == IP_MINIMAL || what == IP_CMDLINE || what == IP_ALL);
261 int cwd_f = (what == IP_MINIMAL || what == IP_CWD || what == IP_ALL);
262 int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
263 int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
264 int status_f = (what == IP_STATUS || what == IP_ALL);
265 int stat_f = (what == IP_STAT || what == IP_ALL);
270 if (args && isdigit (args[0]))
271 pid = strtoul (args, &args, 10);
274 if (!target_has_execution)
275 error (_("No current process: you must name one."));
276 if (current_inferior ()->fake_pid_p)
277 error (_("Can't determine the current process's PID: you must name one."));
279 pid = current_inferior ()->pid;
282 args = skip_spaces (args);
284 error (_("Too many parameters: %s"), args);
286 printf_filtered (_("process %ld\n"), pid);
289 xsnprintf (filename, sizeof filename, "/proc/%ld/cmdline", pid);
290 data = target_fileio_read_stralloc (filename);
293 struct cleanup *cleanup = make_cleanup (xfree, data);
294 printf_filtered ("cmdline = '%s'\n", data);
295 do_cleanups (cleanup);
298 warning (_("unable to open /proc file '%s'"), filename);
302 xsnprintf (filename, sizeof filename, "/proc/%ld/cwd", pid);
303 data = target_fileio_readlink (filename, &target_errno);
306 struct cleanup *cleanup = make_cleanup (xfree, data);
307 printf_filtered ("cwd = '%s'\n", data);
308 do_cleanups (cleanup);
311 warning (_("unable to read link '%s'"), filename);
315 xsnprintf (filename, sizeof filename, "/proc/%ld/exe", pid);
316 data = target_fileio_readlink (filename, &target_errno);
319 struct cleanup *cleanup = make_cleanup (xfree, data);
320 printf_filtered ("exe = '%s'\n", data);
321 do_cleanups (cleanup);
324 warning (_("unable to read link '%s'"), filename);
328 xsnprintf (filename, sizeof filename, "/proc/%ld/maps", pid);
329 data = target_fileio_read_stralloc (filename);
332 struct cleanup *cleanup = make_cleanup (xfree, data);
335 printf_filtered (_("Mapped address spaces:\n\n"));
336 if (gdbarch_addr_bit (gdbarch) == 32)
338 printf_filtered ("\t%10s %10s %10s %10s %s\n",
341 " Size", " Offset", "objfile");
345 printf_filtered (" %18s %18s %10s %10s %s\n",
348 " Size", " Offset", "objfile");
351 for (line = strtok (data, "\n"); line; line = strtok (NULL, "\n"))
353 ULONGEST addr, endaddr, offset, inode;
354 const char *permissions, *device, *filename;
355 size_t permissions_len, device_len;
357 read_mapping (line, &addr, &endaddr,
358 &permissions, &permissions_len,
359 &offset, &device, &device_len,
362 if (gdbarch_addr_bit (gdbarch) == 32)
364 printf_filtered ("\t%10s %10s %10s %10s %s\n",
365 paddress (gdbarch, addr),
366 paddress (gdbarch, endaddr),
367 hex_string (endaddr - addr),
369 *filename? filename : "");
373 printf_filtered (" %18s %18s %10s %10s %s\n",
374 paddress (gdbarch, addr),
375 paddress (gdbarch, endaddr),
376 hex_string (endaddr - addr),
378 *filename? filename : "");
382 do_cleanups (cleanup);
385 warning (_("unable to open /proc file '%s'"), filename);
389 xsnprintf (filename, sizeof filename, "/proc/%ld/status", pid);
390 data = target_fileio_read_stralloc (filename);
393 struct cleanup *cleanup = make_cleanup (xfree, data);
394 puts_filtered (data);
395 do_cleanups (cleanup);
398 warning (_("unable to open /proc file '%s'"), filename);
402 xsnprintf (filename, sizeof filename, "/proc/%ld/stat", pid);
403 data = target_fileio_read_stralloc (filename);
406 struct cleanup *cleanup = make_cleanup (xfree, data);
407 const char *p = data;
409 printf_filtered (_("Process: %s\n"),
410 pulongest (strtoulst (p, &p, 10)));
412 while (*p && isspace (*p))
416 const char *ep = strchr (p, ')');
419 printf_filtered ("Exec file: %.*s\n",
420 (int) (ep - p - 1), p + 1);
425 while (*p && isspace (*p))
428 printf_filtered (_("State: %c\n"), *p++);
431 printf_filtered (_("Parent process: %s\n"),
432 pulongest (strtoulst (p, &p, 10)));
434 printf_filtered (_("Process group: %s\n"),
435 pulongest (strtoulst (p, &p, 10)));
437 printf_filtered (_("Session id: %s\n"),
438 pulongest (strtoulst (p, &p, 10)));
440 printf_filtered (_("TTY: %s\n"),
441 pulongest (strtoulst (p, &p, 10)));
443 printf_filtered (_("TTY owner process group: %s\n"),
444 pulongest (strtoulst (p, &p, 10)));
447 printf_filtered (_("Flags: %s\n"),
448 hex_string (strtoulst (p, &p, 10)));
450 printf_filtered (_("Minor faults (no memory page): %s\n"),
451 pulongest (strtoulst (p, &p, 10)));
453 printf_filtered (_("Minor faults, children: %s\n"),
454 pulongest (strtoulst (p, &p, 10)));
456 printf_filtered (_("Major faults (memory page faults): %s\n"),
457 pulongest (strtoulst (p, &p, 10)));
459 printf_filtered (_("Major faults, children: %s\n"),
460 pulongest (strtoulst (p, &p, 10)));
462 printf_filtered (_("utime: %s\n"),
463 pulongest (strtoulst (p, &p, 10)));
465 printf_filtered (_("stime: %s\n"),
466 pulongest (strtoulst (p, &p, 10)));
468 printf_filtered (_("utime, children: %s\n"),
469 pulongest (strtoulst (p, &p, 10)));
471 printf_filtered (_("stime, children: %s\n"),
472 pulongest (strtoulst (p, &p, 10)));
474 printf_filtered (_("jiffies remaining in current "
476 pulongest (strtoulst (p, &p, 10)));
478 printf_filtered (_("'nice' value: %s\n"),
479 pulongest (strtoulst (p, &p, 10)));
481 printf_filtered (_("jiffies until next timeout: %s\n"),
482 pulongest (strtoulst (p, &p, 10)));
484 printf_filtered (_("jiffies until next SIGALRM: %s\n"),
485 pulongest (strtoulst (p, &p, 10)));
487 printf_filtered (_("start time (jiffies since "
488 "system boot): %s\n"),
489 pulongest (strtoulst (p, &p, 10)));
491 printf_filtered (_("Virtual memory size: %s\n"),
492 pulongest (strtoulst (p, &p, 10)));
494 printf_filtered (_("Resident set size: %s\n"),
495 pulongest (strtoulst (p, &p, 10)));
497 printf_filtered (_("rlim: %s\n"),
498 pulongest (strtoulst (p, &p, 10)));
500 printf_filtered (_("Start of text: %s\n"),
501 hex_string (strtoulst (p, &p, 10)));
503 printf_filtered (_("End of text: %s\n"),
504 hex_string (strtoulst (p, &p, 10)));
506 printf_filtered (_("Start of stack: %s\n"),
507 hex_string (strtoulst (p, &p, 10)));
508 #if 0 /* Don't know how architecture-dependent the rest is...
509 Anyway the signal bitmap info is available from "status". */
511 printf_filtered (_("Kernel stack pointer: %s\n"),
512 hex_string (strtoulst (p, &p, 10)));
514 printf_filtered (_("Kernel instr pointer: %s\n"),
515 hex_string (strtoulst (p, &p, 10)));
517 printf_filtered (_("Pending signals bitmap: %s\n"),
518 hex_string (strtoulst (p, &p, 10)));
520 printf_filtered (_("Blocked signals bitmap: %s\n"),
521 hex_string (strtoulst (p, &p, 10)));
523 printf_filtered (_("Ignored signals bitmap: %s\n"),
524 hex_string (strtoulst (p, &p, 10)));
526 printf_filtered (_("Catched signals bitmap: %s\n"),
527 hex_string (strtoulst (p, &p, 10)));
529 printf_filtered (_("wchan (system call): %s\n"),
530 hex_string (strtoulst (p, &p, 10)));
532 do_cleanups (cleanup);
535 warning (_("unable to open /proc file '%s'"), filename);
539 /* Implement "info proc mappings" for a corefile. */
542 linux_core_info_proc_mappings (struct gdbarch *gdbarch, char *args)
545 ULONGEST count, page_size;
546 unsigned char *descdata, *filenames, *descend, *contents;
548 unsigned int addr_size_bits, addr_size;
549 struct cleanup *cleanup;
550 struct gdbarch *core_gdbarch = gdbarch_from_bfd (core_bfd);
551 /* We assume this for reading 64-bit core files. */
552 gdb_static_assert (sizeof (ULONGEST) >= 8);
554 section = bfd_get_section_by_name (core_bfd, ".note.linuxcore.file");
557 warning (_("unable to find mappings in core file"));
561 addr_size_bits = gdbarch_addr_bit (core_gdbarch);
562 addr_size = addr_size_bits / 8;
563 note_size = bfd_get_section_size (section);
565 if (note_size < 2 * addr_size)
566 error (_("malformed core note - too short for header"));
568 contents = xmalloc (note_size);
569 cleanup = make_cleanup (xfree, contents);
570 if (!bfd_get_section_contents (core_bfd, section, contents, 0, note_size))
571 error (_("could not get core note contents"));
574 descend = descdata + note_size;
576 if (descdata[note_size - 1] != '\0')
577 error (_("malformed note - does not end with \\0"));
579 count = bfd_get (addr_size_bits, core_bfd, descdata);
580 descdata += addr_size;
582 page_size = bfd_get (addr_size_bits, core_bfd, descdata);
583 descdata += addr_size;
585 if (note_size < 2 * addr_size + count * 3 * addr_size)
586 error (_("malformed note - too short for supplied file count"));
588 printf_filtered (_("Mapped address spaces:\n\n"));
589 if (gdbarch_addr_bit (gdbarch) == 32)
591 printf_filtered ("\t%10s %10s %10s %10s %s\n",
594 " Size", " Offset", "objfile");
598 printf_filtered (" %18s %18s %10s %10s %s\n",
601 " Size", " Offset", "objfile");
604 filenames = descdata + count * 3 * addr_size;
607 ULONGEST start, end, file_ofs;
609 if (filenames == descend)
610 error (_("malformed note - filenames end too early"));
612 start = bfd_get (addr_size_bits, core_bfd, descdata);
613 descdata += addr_size;
614 end = bfd_get (addr_size_bits, core_bfd, descdata);
615 descdata += addr_size;
616 file_ofs = bfd_get (addr_size_bits, core_bfd, descdata);
617 descdata += addr_size;
619 file_ofs *= page_size;
621 if (gdbarch_addr_bit (gdbarch) == 32)
622 printf_filtered ("\t%10s %10s %10s %10s %s\n",
623 paddress (gdbarch, start),
624 paddress (gdbarch, end),
625 hex_string (end - start),
626 hex_string (file_ofs),
629 printf_filtered (" %18s %18s %10s %10s %s\n",
630 paddress (gdbarch, start),
631 paddress (gdbarch, end),
632 hex_string (end - start),
633 hex_string (file_ofs),
636 filenames += 1 + strlen ((char *) filenames);
639 do_cleanups (cleanup);
642 /* Implement "info proc" for a corefile. */
645 linux_core_info_proc (struct gdbarch *gdbarch, char *args,
646 enum info_proc_what what)
648 int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
649 int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
655 exe = bfd_core_file_failing_command (core_bfd);
657 printf_filtered ("exe = '%s'\n", exe);
659 warning (_("unable to find command name in core file"));
663 linux_core_info_proc_mappings (gdbarch, args);
665 if (!exe_f && !mappings_f)
666 error (_("unable to handle request"));
669 typedef int linux_find_memory_region_ftype (ULONGEST vaddr, ULONGEST size,
670 ULONGEST offset, ULONGEST inode,
672 int exec, int modified,
673 const char *filename,
676 /* List memory regions in the inferior for a corefile. */
679 linux_find_memory_regions_full (struct gdbarch *gdbarch,
680 linux_find_memory_region_ftype *func,
686 /* We need to know the real target PID to access /proc. */
687 if (current_inferior ()->fake_pid_p)
690 xsnprintf (filename, sizeof filename,
691 "/proc/%d/smaps", current_inferior ()->pid);
692 data = target_fileio_read_stralloc (filename);
695 /* Older Linux kernels did not support /proc/PID/smaps. */
696 xsnprintf (filename, sizeof filename,
697 "/proc/%d/maps", current_inferior ()->pid);
698 data = target_fileio_read_stralloc (filename);
702 struct cleanup *cleanup = make_cleanup (xfree, data);
705 line = strtok (data, "\n");
708 ULONGEST addr, endaddr, offset, inode;
709 const char *permissions, *device, *filename;
710 size_t permissions_len, device_len;
711 int read, write, exec;
712 int modified = 0, has_anonymous = 0;
714 read_mapping (line, &addr, &endaddr, &permissions, &permissions_len,
715 &offset, &device, &device_len, &inode, &filename);
717 /* Decode permissions. */
718 read = (memchr (permissions, 'r', permissions_len) != 0);
719 write = (memchr (permissions, 'w', permissions_len) != 0);
720 exec = (memchr (permissions, 'x', permissions_len) != 0);
722 /* Try to detect if region was modified by parsing smaps counters. */
723 for (line = strtok (NULL, "\n");
724 line && line[0] >= 'A' && line[0] <= 'Z';
725 line = strtok (NULL, "\n"))
727 char keyword[64 + 1];
728 unsigned long number;
730 if (sscanf (line, "%64s%lu kB\n", keyword, &number) != 2)
732 warning (_("Error parsing {s,}maps file '%s'"), filename);
735 if (strcmp (keyword, "Anonymous:") == 0)
737 if (number != 0 && (strcmp (keyword, "Shared_Dirty:") == 0
738 || strcmp (keyword, "Private_Dirty:") == 0
739 || strcmp (keyword, "Swap:") == 0
740 || strcmp (keyword, "Anonymous:") == 0))
744 /* Older Linux kernels did not support the "Anonymous:" counter.
745 If it is missing, we can't be sure - dump all the pages. */
749 /* Invoke the callback function to create the corefile segment. */
750 func (addr, endaddr - addr, offset, inode,
751 read, write, exec, modified, filename, obfd);
754 do_cleanups (cleanup);
761 /* A structure for passing information through
762 linux_find_memory_regions_full. */
764 struct linux_find_memory_regions_data
766 /* The original callback. */
768 find_memory_region_ftype func;
770 /* The original datum. */
775 /* A callback for linux_find_memory_regions that converts between the
776 "full"-style callback and find_memory_region_ftype. */
779 linux_find_memory_regions_thunk (ULONGEST vaddr, ULONGEST size,
780 ULONGEST offset, ULONGEST inode,
781 int read, int write, int exec, int modified,
782 const char *filename, void *arg)
784 struct linux_find_memory_regions_data *data = arg;
786 return data->func (vaddr, size, read, write, exec, modified, data->obfd);
789 /* A variant of linux_find_memory_regions_full that is suitable as the
790 gdbarch find_memory_regions method. */
793 linux_find_memory_regions (struct gdbarch *gdbarch,
794 find_memory_region_ftype func, void *obfd)
796 struct linux_find_memory_regions_data data;
801 return linux_find_memory_regions_full (gdbarch,
802 linux_find_memory_regions_thunk,
806 /* Determine which signal stopped execution. */
809 find_signalled_thread (struct thread_info *info, void *data)
811 if (info->suspend.stop_signal != GDB_SIGNAL_0
812 && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
818 static enum gdb_signal
819 find_stop_signal (void)
821 struct thread_info *info =
822 iterate_over_threads (find_signalled_thread, NULL);
825 return info->suspend.stop_signal;
830 /* Generate corefile notes for SPU contexts. */
833 linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
835 static const char *spu_files[] =
857 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
861 /* Determine list of SPU ids. */
862 size = target_read_alloc (¤t_target, TARGET_OBJECT_SPU,
865 /* Generate corefile notes for each SPU file. */
866 for (i = 0; i < size; i += 4)
868 int fd = extract_unsigned_integer (spu_ids + i, 4, byte_order);
870 for (j = 0; j < sizeof (spu_files) / sizeof (spu_files[0]); j++)
872 char annex[32], note_name[32];
876 xsnprintf (annex, sizeof annex, "%d/%s", fd, spu_files[j]);
877 spu_len = target_read_alloc (¤t_target, TARGET_OBJECT_SPU,
881 xsnprintf (note_name, sizeof note_name, "SPU/%s", annex);
882 note_data = elfcore_write_note (obfd, note_data, note_size,
902 /* This is used to pass information from
903 linux_make_mappings_corefile_notes through
904 linux_find_memory_regions_full. */
906 struct linux_make_mappings_data
908 /* Number of files mapped. */
911 /* The obstack for the main part of the data. */
912 struct obstack *data_obstack;
914 /* The filename obstack. */
915 struct obstack *filename_obstack;
917 /* The architecture's "long" type. */
918 struct type *long_type;
921 static linux_find_memory_region_ftype linux_make_mappings_callback;
923 /* A callback for linux_find_memory_regions_full that updates the
924 mappings data for linux_make_mappings_corefile_notes. */
927 linux_make_mappings_callback (ULONGEST vaddr, ULONGEST size,
928 ULONGEST offset, ULONGEST inode,
929 int read, int write, int exec, int modified,
930 const char *filename, void *data)
932 struct linux_make_mappings_data *map_data = data;
933 gdb_byte buf[sizeof (ULONGEST)];
935 if (*filename == '\0' || inode == 0)
938 ++map_data->file_count;
940 pack_long (buf, map_data->long_type, vaddr);
941 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
942 pack_long (buf, map_data->long_type, vaddr + size);
943 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
944 pack_long (buf, map_data->long_type, offset);
945 obstack_grow (map_data->data_obstack, buf, TYPE_LENGTH (map_data->long_type));
947 obstack_grow_str0 (map_data->filename_obstack, filename);
952 /* Write the file mapping data to the core file, if possible. OBFD is
953 the output BFD. NOTE_DATA is the current note data, and NOTE_SIZE
954 is a pointer to the note size. Returns the new NOTE_DATA and
955 updates NOTE_SIZE. */
958 linux_make_mappings_corefile_notes (struct gdbarch *gdbarch, bfd *obfd,
959 char *note_data, int *note_size)
961 struct cleanup *cleanup;
962 struct obstack data_obstack, filename_obstack;
963 struct linux_make_mappings_data mapping_data;
964 struct type *long_type
965 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch), 0, "long");
966 gdb_byte buf[sizeof (ULONGEST)];
968 obstack_init (&data_obstack);
969 cleanup = make_cleanup_obstack_free (&data_obstack);
970 obstack_init (&filename_obstack);
971 make_cleanup_obstack_free (&filename_obstack);
973 mapping_data.file_count = 0;
974 mapping_data.data_obstack = &data_obstack;
975 mapping_data.filename_obstack = &filename_obstack;
976 mapping_data.long_type = long_type;
978 /* Reserve space for the count. */
979 obstack_blank (&data_obstack, TYPE_LENGTH (long_type));
980 /* We always write the page size as 1 since we have no good way to
981 determine the correct value. */
982 pack_long (buf, long_type, 1);
983 obstack_grow (&data_obstack, buf, TYPE_LENGTH (long_type));
985 linux_find_memory_regions_full (gdbarch, linux_make_mappings_callback,
988 if (mapping_data.file_count != 0)
990 /* Write the count to the obstack. */
991 pack_long (obstack_base (&data_obstack), long_type,
992 mapping_data.file_count);
994 /* Copy the filenames to the data obstack. */
995 obstack_grow (&data_obstack, obstack_base (&filename_obstack),
996 obstack_object_size (&filename_obstack));
998 note_data = elfcore_write_note (obfd, note_data, note_size,
1000 obstack_base (&data_obstack),
1001 obstack_object_size (&data_obstack));
1004 do_cleanups (cleanup);
1008 /* Records the thread's register state for the corefile note
1012 linux_collect_thread_registers (const struct regcache *regcache,
1013 ptid_t ptid, bfd *obfd,
1014 char *note_data, int *note_size,
1015 enum gdb_signal stop_signal)
1017 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1018 struct core_regset_section *sect_list;
1021 sect_list = gdbarch_core_regset_sections (gdbarch);
1022 gdb_assert (sect_list);
1024 /* For remote targets the LWP may not be available, so use the TID. */
1025 lwp = ptid_get_lwp (ptid);
1027 lwp = ptid_get_tid (ptid);
1029 while (sect_list->sect_name != NULL)
1031 const struct regset *regset;
1034 regset = gdbarch_regset_from_core_section (gdbarch,
1035 sect_list->sect_name,
1037 gdb_assert (regset && regset->collect_regset);
1039 buf = xmalloc (sect_list->size);
1040 regset->collect_regset (regset, regcache, -1, buf, sect_list->size);
1042 /* PRSTATUS still needs to be treated specially. */
1043 if (strcmp (sect_list->sect_name, ".reg") == 0)
1044 note_data = (char *) elfcore_write_prstatus
1045 (obfd, note_data, note_size, lwp,
1046 gdb_signal_to_host (stop_signal), buf);
1048 note_data = (char *) elfcore_write_register_note
1049 (obfd, note_data, note_size,
1050 sect_list->sect_name, buf, sect_list->size);
1061 /* Fetch the siginfo data for the current thread, if it exists. If
1062 there is no data, or we could not read it, return NULL. Otherwise,
1063 return a newly malloc'd buffer holding the data and fill in *SIZE
1064 with the size of the data. The caller is responsible for freeing
1068 linux_get_siginfo_data (struct gdbarch *gdbarch, LONGEST *size)
1070 struct type *siginfo_type;
1073 struct cleanup *cleanups;
1075 if (!gdbarch_get_siginfo_type_p (gdbarch))
1078 siginfo_type = gdbarch_get_siginfo_type (gdbarch);
1080 buf = xmalloc (TYPE_LENGTH (siginfo_type));
1081 cleanups = make_cleanup (xfree, buf);
1083 bytes_read = target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL,
1084 buf, 0, TYPE_LENGTH (siginfo_type));
1085 if (bytes_read == TYPE_LENGTH (siginfo_type))
1087 discard_cleanups (cleanups);
1092 do_cleanups (cleanups);
1099 struct linux_corefile_thread_data
1101 struct gdbarch *gdbarch;
1107 enum gdb_signal stop_signal;
1108 linux_collect_thread_registers_ftype collect;
1111 /* Called by gdbthread.c once per thread. Records the thread's
1112 register state for the corefile note section. */
1115 linux_corefile_thread_callback (struct thread_info *info, void *data)
1117 struct linux_corefile_thread_data *args = data;
1119 if (ptid_get_pid (info->ptid) == args->pid)
1121 struct cleanup *old_chain;
1122 struct regcache *regcache;
1123 gdb_byte *siginfo_data;
1124 LONGEST siginfo_size;
1126 regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
1128 old_chain = save_inferior_ptid ();
1129 inferior_ptid = info->ptid;
1130 target_fetch_registers (regcache, -1);
1131 siginfo_data = linux_get_siginfo_data (args->gdbarch, &siginfo_size);
1132 do_cleanups (old_chain);
1134 old_chain = make_cleanup (xfree, siginfo_data);
1136 args->note_data = args->collect (regcache, info->ptid, args->obfd,
1137 args->note_data, args->note_size,
1141 if (siginfo_data != NULL)
1143 args->note_data = elfcore_write_note (args->obfd,
1147 siginfo_data, siginfo_size);
1151 do_cleanups (old_chain);
1154 return !args->note_data;
1157 /* Fill the PRPSINFO structure with information about the process being
1158 debugged. Returns 1 in case of success, 0 for failures. Please note that
1159 even if the structure cannot be entirely filled (e.g., GDB was unable to
1160 gather information about the process UID/GID), this function will still
1161 return 1 since some information was already recorded. It will only return
1162 0 iff nothing can be gathered. */
1165 linux_fill_prpsinfo (struct elf_internal_linux_prpsinfo *p)
1167 /* The filename which we will use to obtain some info about the process.
1168 We will basically use this to store the `/proc/PID/FILENAME' file. */
1170 /* The full name of the program which generated the corefile. */
1172 /* The basename of the executable. */
1173 const char *basename;
1174 /* The arguments of the program. */
1177 /* The contents of `/proc/PID/stat' and `/proc/PID/status' files. */
1178 char *proc_stat, *proc_status;
1179 /* Temporary buffer. */
1181 /* The valid states of a process, according to the Linux kernel. */
1182 const char valid_states[] = "RSDTZW";
1183 /* The program state. */
1184 const char *prog_state;
1185 /* The state of the process. */
1187 /* The PID of the program which generated the corefile. */
1189 /* Process flags. */
1190 unsigned int pr_flag;
1191 /* Process nice value. */
1193 /* The number of fields read by `sscanf'. */
1199 gdb_assert (p != NULL);
1201 /* Obtaining PID and filename. */
1202 pid = ptid_get_pid (inferior_ptid);
1203 xsnprintf (filename, sizeof (filename), "/proc/%d/cmdline", (int) pid);
1204 fname = target_fileio_read_stralloc (filename);
1206 if (fname == NULL || *fname == '\0')
1208 /* No program name was read, so we won't be able to retrieve more
1209 information about the process. */
1214 c = make_cleanup (xfree, fname);
1215 memset (p, 0, sizeof (*p));
1217 /* Defining the PID. */
1220 /* Copying the program name. Only the basename matters. */
1221 basename = lbasename (fname);
1222 strncpy (p->pr_fname, basename, sizeof (p->pr_fname));
1223 p->pr_fname[sizeof (p->pr_fname) - 1] = '\0';
1225 infargs = get_inferior_args ();
1227 psargs = xstrdup (fname);
1228 if (infargs != NULL)
1229 psargs = reconcat (psargs, psargs, " ", infargs, NULL);
1231 make_cleanup (xfree, psargs);
1233 strncpy (p->pr_psargs, psargs, sizeof (p->pr_psargs));
1234 p->pr_psargs[sizeof (p->pr_psargs) - 1] = '\0';
1236 xsnprintf (filename, sizeof (filename), "/proc/%d/stat", (int) pid);
1237 proc_stat = target_fileio_read_stralloc (filename);
1238 make_cleanup (xfree, proc_stat);
1240 if (proc_stat == NULL || *proc_stat == '\0')
1242 /* Despite being unable to read more information about the
1243 process, we return 1 here because at least we have its
1244 command line, PID and arguments. */
1249 /* Ok, we have the stats. It's time to do a little parsing of the
1250 contents of the buffer, so that we end up reading what we want.
1252 The following parsing mechanism is strongly based on the
1253 information generated by the `fs/proc/array.c' file, present in
1254 the Linux kernel tree. More details about how the information is
1255 displayed can be obtained by seeing the manpage of proc(5),
1256 specifically under the entry of `/proc/[pid]/stat'. */
1258 /* Getting rid of the PID, since we already have it. */
1259 while (isdigit (*proc_stat))
1262 proc_stat = skip_spaces (proc_stat);
1264 /* Getting rid of the executable name, since we already have it. We
1265 know that this name will be in parentheses, so we can safely look
1266 for the close-paren. */
1267 while (*proc_stat != ')')
1271 proc_stat = skip_spaces (proc_stat);
1273 n_fields = sscanf (proc_stat,
1274 "%c" /* Process state. */
1275 "%d%d%d" /* Parent PID, group ID, session ID. */
1276 "%*d%*d" /* tty_nr, tpgid (not used). */
1278 "%*s%*s%*s%*s" /* minflt, cminflt, majflt,
1279 cmajflt (not used). */
1280 "%*s%*s%*s%*s" /* utime, stime, cutime,
1281 cstime (not used). */
1282 "%*s" /* Priority (not used). */
1285 &p->pr_ppid, &p->pr_pgrp, &p->pr_sid,
1291 /* Again, we couldn't read the complementary information about
1292 the process state. However, we already have minimal
1293 information, so we just return 1 here. */
1298 /* Filling the structure fields. */
1299 prog_state = strchr (valid_states, pr_sname);
1300 if (prog_state != NULL)
1301 p->pr_state = prog_state - valid_states;
1304 /* Zero means "Running". */
1308 p->pr_sname = p->pr_state > 5 ? '.' : pr_sname;
1309 p->pr_zomb = p->pr_sname == 'Z';
1310 p->pr_nice = pr_nice;
1311 p->pr_flag = pr_flag;
1313 /* Finally, obtaining the UID and GID. For that, we read and parse the
1314 contents of the `/proc/PID/status' file. */
1315 xsnprintf (filename, sizeof (filename), "/proc/%d/status", (int) pid);
1316 proc_status = target_fileio_read_stralloc (filename);
1317 make_cleanup (xfree, proc_status);
1319 if (proc_status == NULL || *proc_status == '\0')
1321 /* Returning 1 since we already have a bunch of information. */
1326 /* Extracting the UID. */
1327 tmpstr = strstr (proc_status, "Uid:");
1330 /* Advancing the pointer to the beginning of the UID. */
1331 tmpstr += sizeof ("Uid:");
1332 while (*tmpstr != '\0' && !isdigit (*tmpstr))
1335 if (isdigit (*tmpstr))
1336 p->pr_uid = strtol (tmpstr, &tmpstr, 10);
1339 /* Extracting the GID. */
1340 tmpstr = strstr (proc_status, "Gid:");
1343 /* Advancing the pointer to the beginning of the GID. */
1344 tmpstr += sizeof ("Gid:");
1345 while (*tmpstr != '\0' && !isdigit (*tmpstr))
1348 if (isdigit (*tmpstr))
1349 p->pr_gid = strtol (tmpstr, &tmpstr, 10);
1357 /* Fills the "to_make_corefile_note" target vector. Builds the note
1358 section for a corefile, and returns it in a malloc buffer. */
1361 linux_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size,
1362 linux_collect_thread_registers_ftype collect)
1364 struct linux_corefile_thread_data thread_args;
1365 struct elf_internal_linux_prpsinfo prpsinfo;
1366 char *note_data = NULL;
1370 if (linux_fill_prpsinfo (&prpsinfo))
1372 if (gdbarch_elfcore_write_linux_prpsinfo_p (gdbarch))
1374 note_data = gdbarch_elfcore_write_linux_prpsinfo (gdbarch, obfd,
1375 note_data, note_size,
1380 if (gdbarch_ptr_bit (gdbarch) == 64)
1381 note_data = elfcore_write_linux_prpsinfo64 (obfd,
1382 note_data, note_size,
1385 note_data = elfcore_write_linux_prpsinfo32 (obfd,
1386 note_data, note_size,
1391 /* Thread register information. */
1392 thread_args.gdbarch = gdbarch;
1393 thread_args.pid = ptid_get_pid (inferior_ptid);
1394 thread_args.obfd = obfd;
1395 thread_args.note_data = note_data;
1396 thread_args.note_size = note_size;
1397 thread_args.num_notes = 0;
1398 thread_args.stop_signal = find_stop_signal ();
1399 thread_args.collect = collect;
1400 iterate_over_threads (linux_corefile_thread_callback, &thread_args);
1401 note_data = thread_args.note_data;
1405 /* Auxillary vector. */
1406 auxv_len = target_read_alloc (¤t_target, TARGET_OBJECT_AUXV,
1410 note_data = elfcore_write_note (obfd, note_data, note_size,
1411 "CORE", NT_AUXV, auxv, auxv_len);
1418 /* SPU information. */
1419 note_data = linux_spu_make_corefile_notes (obfd, note_data, note_size);
1423 /* File mappings. */
1424 note_data = linux_make_mappings_corefile_notes (gdbarch, obfd,
1425 note_data, note_size);
1427 make_cleanup (xfree, note_data);
1432 linux_make_corefile_notes_1 (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
1434 /* FIXME: uweigand/2011-10-06: Once all GNU/Linux architectures have been
1435 converted to gdbarch_core_regset_sections, we no longer need to fall back
1436 to the target method at this point. */
1438 if (!gdbarch_core_regset_sections (gdbarch))
1439 return target_make_corefile_notes (obfd, note_size);
1441 return linux_make_corefile_notes (gdbarch, obfd, note_size,
1442 linux_collect_thread_registers);
1445 /* To be called from the various GDB_OSABI_LINUX handlers for the
1446 various GNU/Linux architectures and machine types. */
1449 linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1451 set_gdbarch_core_pid_to_str (gdbarch, linux_core_pid_to_str);
1452 set_gdbarch_info_proc (gdbarch, linux_info_proc);
1453 set_gdbarch_core_info_proc (gdbarch, linux_core_info_proc);
1454 set_gdbarch_find_memory_regions (gdbarch, linux_find_memory_regions);
1455 set_gdbarch_make_corefile_notes (gdbarch, linux_make_corefile_notes_1);
1456 set_gdbarch_has_shared_address_space (gdbarch,
1457 linux_has_shared_address_space);
1460 /* Provide a prototype to silence -Wmissing-prototypes. */
1461 extern initialize_file_ftype _initialize_linux_tdep;
1464 _initialize_linux_tdep (void)
1466 linux_gdbarch_data_handle =
1467 gdbarch_data_register_post_init (init_linux_gdbarch_data);