/* Target-dependent code for FreeBSD, architecture-independent.
Copyright (C) 2002-2017 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 . */
#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"
/* FreeBSD kernels 12.0 and later include a copy of the
'ptrace_lwpinfo' structure returned by the PT_LWPINFO ptrace
operation in an ELF core note (NT_FREEBSD_PTLWPINFO) for each LWP.
The constants below define the offset of field members and flags in
this structure used by methods in this file. Note that the
'ptrace_lwpinfo' struct in the note is preceded by a 4 byte integer
containing the size of the structure. */
#define LWPINFO_OFFSET 0x4
/* Offsets in ptrace_lwpinfo. */
#define LWPINFO_PL_FLAGS 0x8
#define LWPINFO64_PL_SIGINFO 0x30
#define LWPINFO32_PL_SIGINFO 0x2c
/* Flags in pl_flags. */
#define PL_FLAG_SI 0x20 /* siginfo is valid */
/* Sizes of siginfo_t. */
#define SIZE64_SIGINFO_T 80
#define SIZE32_SIGINFO_T 64
static struct gdbarch_data *fbsd_gdbarch_data_handle;
struct fbsd_gdbarch_data
{
struct type *siginfo_type;
};
static void *
init_fbsd_gdbarch_data (struct gdbarch *gdbarch)
{
return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct fbsd_gdbarch_data);
}
static struct fbsd_gdbarch_data *
get_fbsd_gdbarch_data (struct gdbarch *gdbarch)
{
return ((struct fbsd_gdbarch_data *)
gdbarch_data (gdbarch, fbsd_gdbarch_data_handle));
}
/* This is how we want PTIDs from core files to be printed. */
static const 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;
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
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. */
thread_section_name section_name (".thrmisc", thr->ptid);
section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
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;
}
/* Implement the "core_xfer_siginfo" gdbarch method. */
static LONGEST
fbsd_core_xfer_siginfo (struct gdbarch *gdbarch, gdb_byte *readbuf,
ULONGEST offset, ULONGEST len)
{
size_t siginfo_size;
if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
siginfo_size = SIZE32_SIGINFO_T;
else
siginfo_size = SIZE64_SIGINFO_T;
if (offset > siginfo_size)
return -1;
thread_section_name section_name (".note.freebsdcore.lwpinfo", inferior_ptid);
asection *section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
if (section == NULL)
return -1;
gdb_byte buf[4];
if (!bfd_get_section_contents (core_bfd, section, buf,
LWPINFO_OFFSET + LWPINFO_PL_FLAGS, 4))
return -1;
int pl_flags = extract_signed_integer (buf, 4, gdbarch_byte_order (gdbarch));
if (!(pl_flags & PL_FLAG_SI))
return -1;
if (offset + len > siginfo_size)
len = siginfo_size - offset;
ULONGEST siginfo_offset;
if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
siginfo_offset = LWPINFO_OFFSET + LWPINFO32_PL_SIGINFO;
else
siginfo_offset = LWPINFO_OFFSET + LWPINFO64_PL_SIGINFO;
if (!bfd_get_section_contents (core_bfd, section, readbuf,
siginfo_offset + offset, len))
return -1;
return len;
}
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 regcache *regcache;
regcache = get_thread_arch_regcache (info->ptid, args->gdbarch);
target_fetch_registers (regcache, -1);
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_siginfo_type" gdbarch method. */
static struct type *
fbsd_get_siginfo_type (struct gdbarch *gdbarch)
{
struct fbsd_gdbarch_data *fbsd_gdbarch_data;
struct type *int_type, *int32_type, *uint32_type, *long_type, *void_ptr_type;
struct type *uid_type, *pid_type;
struct type *sigval_type, *reason_type;
struct type *siginfo_type;
struct type *type;
fbsd_gdbarch_data = get_fbsd_gdbarch_data (gdbarch);
if (fbsd_gdbarch_data->siginfo_type != NULL)
return fbsd_gdbarch_data->siginfo_type;
int_type = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
0, "int");
int32_type = arch_integer_type (gdbarch, 32, 0, "int32_t");
uint32_type = arch_integer_type (gdbarch, 32, 1, "uint32_t");
long_type = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
0, "long");
void_ptr_type = lookup_pointer_type (builtin_type (gdbarch)->builtin_void);
/* union sigval */
sigval_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
TYPE_NAME (sigval_type) = xstrdup ("sigval");
append_composite_type_field (sigval_type, "sival_int", int_type);
append_composite_type_field (sigval_type, "sival_ptr", void_ptr_type);
/* __pid_t */
pid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
TYPE_LENGTH (int32_type), "__pid_t");
TYPE_TARGET_TYPE (pid_type) = int32_type;
TYPE_TARGET_STUB (pid_type) = 1;
/* __uid_t */
uid_type = arch_type (gdbarch, TYPE_CODE_TYPEDEF,
TYPE_LENGTH (uint32_type), "__uid_t");
TYPE_TARGET_TYPE (uid_type) = uint32_type;
TYPE_TARGET_STUB (uid_type) = 1;
/* _reason */
reason_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
/* _fault */
type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
append_composite_type_field (type, "si_trapno", int_type);
append_composite_type_field (reason_type, "_fault", type);
/* _timer */
type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
append_composite_type_field (type, "si_timerid", int_type);
append_composite_type_field (type, "si_overrun", int_type);
append_composite_type_field (reason_type, "_timer", type);
/* _mesgq */
type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
append_composite_type_field (type, "si_mqd", int_type);
append_composite_type_field (reason_type, "_mesgq", type);
/* _poll */
type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
append_composite_type_field (type, "si_band", long_type);
append_composite_type_field (reason_type, "_poll", type);
/* __spare__ */
type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
append_composite_type_field (type, "__spare1__", long_type);
append_composite_type_field (type, "__spare2__",
init_vector_type (int_type, 7));
append_composite_type_field (reason_type, "__spare__", type);
/* struct siginfo */
siginfo_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
TYPE_NAME (siginfo_type) = xstrdup ("siginfo");
append_composite_type_field (siginfo_type, "si_signo", int_type);
append_composite_type_field (siginfo_type, "si_errno", int_type);
append_composite_type_field (siginfo_type, "si_code", int_type);
append_composite_type_field (siginfo_type, "si_pid", pid_type);
append_composite_type_field (siginfo_type, "si_uid", uid_type);
append_composite_type_field (siginfo_type, "si_status", int_type);
append_composite_type_field (siginfo_type, "si_addr", void_ptr_type);
append_composite_type_field (siginfo_type, "si_value", sigval_type);
append_composite_type_field (siginfo_type, "_reason", reason_type);
fbsd_gdbarch_data->siginfo_type = siginfo_type;
return siginfo_type;
}
/* 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 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_core_xfer_siginfo (gdbarch, fbsd_core_xfer_siginfo);
set_gdbarch_make_corefile_notes (gdbarch, fbsd_make_corefile_notes);
set_gdbarch_print_auxv_entry (gdbarch, fbsd_print_auxv_entry);
set_gdbarch_get_siginfo_type (gdbarch, fbsd_get_siginfo_type);
/* `catch syscall' */
set_xml_syscall_file_name (gdbarch, "syscalls/freebsd.xml");
set_gdbarch_get_syscall_number (gdbarch, fbsd_get_syscall_number);
}
void
_initialize_fbsd_tdep (void)
{
fbsd_gdbarch_data_handle =
gdbarch_data_register_post_init (init_fbsd_gdbarch_data);
}