351 lines
10 KiB
C
351 lines
10 KiB
C
/* Target-dependent code for FreeBSD, architecture-independent.
|
|
|
|
Copyright (C) 2002-2016 Free Software Foundation, Inc.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#include "defs.h"
|
|
#include "auxv.h"
|
|
#include "gdbcore.h"
|
|
#include "inferior.h"
|
|
#include "regcache.h"
|
|
#include "regset.h"
|
|
#include "gdbthread.h"
|
|
#include "xml-syscall.h"
|
|
|
|
#include "elf-bfd.h"
|
|
#include "fbsd-tdep.h"
|
|
|
|
|
|
/* This is how we want PTIDs from core files to be printed. */
|
|
|
|
static char *
|
|
fbsd_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid)
|
|
{
|
|
static char buf[80];
|
|
|
|
if (ptid_get_lwp (ptid) != 0)
|
|
{
|
|
xsnprintf (buf, sizeof buf, "LWP %ld", ptid_get_lwp (ptid));
|
|
return buf;
|
|
}
|
|
|
|
return normal_pid_to_str (ptid);
|
|
}
|
|
|
|
/* Extract the name assigned to a thread from a core. Returns the
|
|
string in a static buffer. */
|
|
|
|
static const char *
|
|
fbsd_core_thread_name (struct gdbarch *gdbarch, struct thread_info *thr)
|
|
{
|
|
static char buf[80];
|
|
struct bfd_section *section;
|
|
bfd_size_type size;
|
|
char sectionstr[32];
|
|
|
|
if (ptid_get_lwp (thr->ptid) != 0)
|
|
{
|
|
/* FreeBSD includes a NT_FREEBSD_THRMISC note for each thread
|
|
whose contents are defined by a "struct thrmisc" declared in
|
|
<sys/procfs.h> on FreeBSD. The per-thread name is stored as
|
|
a null-terminated string as the first member of the
|
|
structure. Rather than define the full structure here, just
|
|
extract the null-terminated name from the start of the
|
|
note. */
|
|
xsnprintf (sectionstr, sizeof sectionstr, ".thrmisc/%ld",
|
|
ptid_get_lwp (thr->ptid));
|
|
section = bfd_get_section_by_name (core_bfd, sectionstr);
|
|
if (section != NULL && bfd_section_size (core_bfd, section) > 0)
|
|
{
|
|
/* Truncate the name if it is longer than "buf". */
|
|
size = bfd_section_size (core_bfd, section);
|
|
if (size > sizeof buf - 1)
|
|
size = sizeof buf - 1;
|
|
if (bfd_get_section_contents (core_bfd, section, buf, (file_ptr) 0,
|
|
size)
|
|
&& buf[0] != '\0')
|
|
{
|
|
buf[size] = '\0';
|
|
|
|
/* Note that each thread will report the process command
|
|
as its thread name instead of an empty name if a name
|
|
has not been set explicitly. Return a NULL name in
|
|
that case. */
|
|
if (strcmp (buf, elf_tdata (core_bfd)->core->program) != 0)
|
|
return buf;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static int
|
|
find_signalled_thread (struct thread_info *info, void *data)
|
|
{
|
|
if (info->suspend.stop_signal != GDB_SIGNAL_0
|
|
&& ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Structure for passing information from
|
|
fbsd_collect_thread_registers via an iterator to
|
|
fbsd_collect_regset_section_cb. */
|
|
|
|
struct fbsd_collect_regset_section_cb_data
|
|
{
|
|
const struct regcache *regcache;
|
|
bfd *obfd;
|
|
char *note_data;
|
|
int *note_size;
|
|
unsigned long lwp;
|
|
enum gdb_signal stop_signal;
|
|
int abort_iteration;
|
|
};
|
|
|
|
static void
|
|
fbsd_collect_regset_section_cb (const char *sect_name, int size,
|
|
const struct regset *regset,
|
|
const char *human_name, void *cb_data)
|
|
{
|
|
char *buf;
|
|
struct fbsd_collect_regset_section_cb_data *data
|
|
= (struct fbsd_collect_regset_section_cb_data *) cb_data;
|
|
|
|
if (data->abort_iteration)
|
|
return;
|
|
|
|
gdb_assert (regset->collect_regset);
|
|
|
|
buf = (char *) xmalloc (size);
|
|
regset->collect_regset (regset, data->regcache, -1, buf, size);
|
|
|
|
/* PRSTATUS still needs to be treated specially. */
|
|
if (strcmp (sect_name, ".reg") == 0)
|
|
data->note_data = (char *) elfcore_write_prstatus
|
|
(data->obfd, data->note_data, data->note_size, data->lwp,
|
|
gdb_signal_to_host (data->stop_signal), buf);
|
|
else
|
|
data->note_data = (char *) elfcore_write_register_note
|
|
(data->obfd, data->note_data, data->note_size,
|
|
sect_name, buf, size);
|
|
xfree (buf);
|
|
|
|
if (data->note_data == NULL)
|
|
data->abort_iteration = 1;
|
|
}
|
|
|
|
/* Records the thread's register state for the corefile note
|
|
section. */
|
|
|
|
static char *
|
|
fbsd_collect_thread_registers (const struct regcache *regcache,
|
|
ptid_t ptid, bfd *obfd,
|
|
char *note_data, int *note_size,
|
|
enum gdb_signal stop_signal)
|
|
{
|
|
struct gdbarch *gdbarch = get_regcache_arch (regcache);
|
|
struct fbsd_collect_regset_section_cb_data data;
|
|
|
|
data.regcache = regcache;
|
|
data.obfd = obfd;
|
|
data.note_data = note_data;
|
|
data.note_size = note_size;
|
|
data.stop_signal = stop_signal;
|
|
data.abort_iteration = 0;
|
|
data.lwp = ptid_get_lwp (ptid);
|
|
|
|
gdbarch_iterate_over_regset_sections (gdbarch,
|
|
fbsd_collect_regset_section_cb,
|
|
&data, regcache);
|
|
return data.note_data;
|
|
}
|
|
|
|
struct fbsd_corefile_thread_data
|
|
{
|
|
struct gdbarch *gdbarch;
|
|
bfd *obfd;
|
|
char *note_data;
|
|
int *note_size;
|
|
enum gdb_signal stop_signal;
|
|
};
|
|
|
|
/* Records the thread's register state for the corefile note
|
|
section. */
|
|
|
|
static void
|
|
fbsd_corefile_thread (struct thread_info *info,
|
|
struct fbsd_corefile_thread_data *args)
|
|
{
|
|
struct cleanup *old_chain;
|
|
struct regcache *regcache;
|
|
|
|
regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
|
|
|
|
old_chain = save_inferior_ptid ();
|
|
inferior_ptid = info->ptid;
|
|
target_fetch_registers (regcache, -1);
|
|
do_cleanups (old_chain);
|
|
|
|
args->note_data = fbsd_collect_thread_registers
|
|
(regcache, info->ptid, args->obfd, args->note_data,
|
|
args->note_size, args->stop_signal);
|
|
}
|
|
|
|
/* Create appropriate note sections for a corefile, returning them in
|
|
allocated memory. */
|
|
|
|
static char *
|
|
fbsd_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
|
|
{
|
|
struct fbsd_corefile_thread_data thread_args;
|
|
char *note_data = NULL;
|
|
Elf_Internal_Ehdr *i_ehdrp;
|
|
struct thread_info *curr_thr, *signalled_thr, *thr;
|
|
|
|
/* Put a "FreeBSD" label in the ELF header. */
|
|
i_ehdrp = elf_elfheader (obfd);
|
|
i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
|
|
|
|
gdb_assert (gdbarch_iterate_over_regset_sections_p (gdbarch));
|
|
|
|
if (get_exec_file (0))
|
|
{
|
|
const char *fname = lbasename (get_exec_file (0));
|
|
char *psargs = xstrdup (fname);
|
|
|
|
if (get_inferior_args ())
|
|
psargs = reconcat (psargs, psargs, " ", get_inferior_args (),
|
|
(char *) NULL);
|
|
|
|
note_data = elfcore_write_prpsinfo (obfd, note_data, note_size,
|
|
fname, psargs);
|
|
}
|
|
|
|
/* Thread register information. */
|
|
TRY
|
|
{
|
|
update_thread_list ();
|
|
}
|
|
CATCH (e, RETURN_MASK_ERROR)
|
|
{
|
|
exception_print (gdb_stderr, e);
|
|
}
|
|
END_CATCH
|
|
|
|
/* Like the kernel, prefer dumping the signalled thread first.
|
|
"First thread" is what tools use to infer the signalled thread.
|
|
In case there's more than one signalled thread, prefer the
|
|
current thread, if it is signalled. */
|
|
curr_thr = inferior_thread ();
|
|
if (curr_thr->suspend.stop_signal != GDB_SIGNAL_0)
|
|
signalled_thr = curr_thr;
|
|
else
|
|
{
|
|
signalled_thr = iterate_over_threads (find_signalled_thread, NULL);
|
|
if (signalled_thr == NULL)
|
|
signalled_thr = curr_thr;
|
|
}
|
|
|
|
thread_args.gdbarch = gdbarch;
|
|
thread_args.obfd = obfd;
|
|
thread_args.note_data = note_data;
|
|
thread_args.note_size = note_size;
|
|
thread_args.stop_signal = signalled_thr->suspend.stop_signal;
|
|
|
|
fbsd_corefile_thread (signalled_thr, &thread_args);
|
|
ALL_NON_EXITED_THREADS (thr)
|
|
{
|
|
if (thr == signalled_thr)
|
|
continue;
|
|
if (ptid_get_pid (thr->ptid) != ptid_get_pid (inferior_ptid))
|
|
continue;
|
|
|
|
fbsd_corefile_thread (thr, &thread_args);
|
|
}
|
|
|
|
note_data = thread_args.note_data;
|
|
|
|
return note_data;
|
|
}
|
|
|
|
/* Print descriptions of FreeBSD-specific AUXV entries to FILE. */
|
|
|
|
static void
|
|
fbsd_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file,
|
|
CORE_ADDR type, CORE_ADDR val)
|
|
{
|
|
const char *name;
|
|
const char *description;
|
|
enum auxv_format format;
|
|
|
|
switch (type)
|
|
{
|
|
#define _TAGNAME(tag) #tag
|
|
#define TAGNAME(tag) _TAGNAME(AT_##tag)
|
|
#define TAG(tag, text, kind) \
|
|
case AT_FREEBSD_##tag: name = TAGNAME(tag); description = text; format = kind; break
|
|
TAG (EXECPATH, _("Executable path"), AUXV_FORMAT_STR);
|
|
TAG (CANARY, _("Canary for SSP"), AUXV_FORMAT_HEX);
|
|
TAG (CANARYLEN, ("Length of the SSP canary"), AUXV_FORMAT_DEC);
|
|
TAG (OSRELDATE, _("OSRELDATE"), AUXV_FORMAT_DEC);
|
|
TAG (NCPUS, _("Number of CPUs"), AUXV_FORMAT_DEC);
|
|
TAG (PAGESIZES, _("Pagesizes"), AUXV_FORMAT_HEX);
|
|
TAG (PAGESIZESLEN, _("Number of pagesizes"), AUXV_FORMAT_DEC);
|
|
TAG (TIMEKEEP, _("Pointer to timehands"), AUXV_FORMAT_HEX);
|
|
TAG (STACKPROT, _("Initial stack protection"), AUXV_FORMAT_HEX);
|
|
default:
|
|
default_print_auxv_entry (gdbarch, file, type, val);
|
|
return;
|
|
}
|
|
|
|
fprint_auxv_entry (file, name, description, format, type, val);
|
|
}
|
|
|
|
/* Implement the "get_syscall_number" gdbarch method. */
|
|
|
|
static LONGEST
|
|
fbsd_get_syscall_number (struct gdbarch *gdbarch,
|
|
ptid_t ptid)
|
|
{
|
|
|
|
/* FreeBSD doesn't use gdbarch_get_syscall_number since FreeBSD
|
|
native targets fetch the system call number from the
|
|
'pl_syscall_code' member of struct ptrace_lwpinfo in fbsd_wait.
|
|
However, system call catching requires this function to be
|
|
set. */
|
|
|
|
internal_error (__FILE__, __LINE__, _("fbsd_get_sycall_number called"));
|
|
}
|
|
|
|
/* To be called from GDB_OSABI_FREEBSD_ELF handlers. */
|
|
|
|
void
|
|
fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
|
|
{
|
|
set_gdbarch_core_pid_to_str (gdbarch, fbsd_core_pid_to_str);
|
|
set_gdbarch_core_thread_name (gdbarch, fbsd_core_thread_name);
|
|
set_gdbarch_make_corefile_notes (gdbarch, fbsd_make_corefile_notes);
|
|
set_gdbarch_print_auxv_entry (gdbarch, fbsd_print_auxv_entry);
|
|
|
|
/* `catch syscall' */
|
|
set_xml_syscall_file_name (gdbarch, "syscalls/freebsd.xml");
|
|
set_gdbarch_get_syscall_number (gdbarch, fbsd_get_syscall_number);
|
|
}
|