2006-07-22 15:27:18 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2004 Marcel Moolenaar
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
*
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
|
|
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
|
|
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
2006-09-14 07:51:52 +00:00
|
|
|
#ifndef CROSS_DEBUGGER
|
2006-07-22 15:27:18 +00:00
|
|
|
#include <machine/pcb.h>
|
|
|
|
#include <machine/frame.h>
|
2006-09-14 07:51:52 +00:00
|
|
|
#include <machine/armreg.h>
|
|
|
|
#endif
|
2006-07-22 15:27:18 +00:00
|
|
|
#include <err.h>
|
|
|
|
#include <kvm.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include <defs.h>
|
|
|
|
#include <target.h>
|
|
|
|
#include <gdbthread.h>
|
|
|
|
#include <inferior.h>
|
|
|
|
#include <regcache.h>
|
|
|
|
#include <frame-unwind.h>
|
|
|
|
#include <arm-tdep.h>
|
|
|
|
|
|
|
|
#include "kgdb.h"
|
|
|
|
|
2013-02-17 02:15:19 +00:00
|
|
|
CORE_ADDR
|
|
|
|
kgdb_trgt_core_pcb(u_int cpuid)
|
|
|
|
{
|
2014-02-12 02:08:42 +00:00
|
|
|
#ifndef CROSS_DEBUGGER
|
2013-02-17 02:15:19 +00:00
|
|
|
return (kgdb_trgt_stop_pcb(cpuid, sizeof(struct pcb)));
|
2014-02-12 02:08:42 +00:00
|
|
|
#else
|
|
|
|
return -1;
|
|
|
|
#endif
|
2013-02-17 02:15:19 +00:00
|
|
|
}
|
|
|
|
|
2006-07-22 15:27:18 +00:00
|
|
|
void
|
|
|
|
kgdb_trgt_fetch_registers(int regno __unused)
|
|
|
|
{
|
2006-09-14 07:51:52 +00:00
|
|
|
#ifndef CROSS_DEBUGGER
|
2006-07-22 15:27:18 +00:00
|
|
|
struct kthr *kt;
|
|
|
|
struct pcb pcb;
|
|
|
|
int i, reg;
|
2006-10-16 20:07:23 +00:00
|
|
|
|
2008-05-01 20:36:48 +00:00
|
|
|
kt = kgdb_thr_lookup_tid(ptid_get_pid(inferior_ptid));
|
2006-07-22 15:27:18 +00:00
|
|
|
if (kt == NULL)
|
|
|
|
return;
|
|
|
|
if (kvm_read(kvm, kt->pcb, &pcb, sizeof(pcb)) != sizeof(pcb)) {
|
|
|
|
warnx("kvm_read: %s", kvm_geterr(kvm));
|
|
|
|
memset(&pcb, 0, sizeof(pcb));
|
|
|
|
}
|
|
|
|
for (i = ARM_A1_REGNUM + 8; i <= ARM_SP_REGNUM; i++) {
|
2006-10-16 20:07:23 +00:00
|
|
|
supply_register(i, (char *)&pcb.un_32.pcb32_r8 +
|
2006-07-22 15:27:18 +00:00
|
|
|
(i - (ARM_A1_REGNUM + 8 )) * 4);
|
|
|
|
}
|
|
|
|
if (pcb.un_32.pcb32_sp != 0) {
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
if (kvm_read(kvm, pcb.un_32.pcb32_sp + (i) * 4,
|
|
|
|
®, 4) != 4) {
|
|
|
|
warnx("kvm_read: %s", kvm_geterr(kvm));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
supply_register(ARM_A1_REGNUM + 4 + i, (char *)®);
|
|
|
|
}
|
|
|
|
if (kvm_read(kvm, pcb.un_32.pcb32_sp + 4 * 4, ®, 4) != 4)
|
|
|
|
warnx("kvm_read :%s", kvm_geterr(kvm));
|
|
|
|
else
|
|
|
|
supply_register(ARM_PC_REGNUM, (char *)®);
|
|
|
|
}
|
2006-09-14 07:51:52 +00:00
|
|
|
#endif
|
2006-07-22 15:27:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
kgdb_trgt_store_registers(int regno __unused)
|
|
|
|
{
|
|
|
|
fprintf_unfiltered(gdb_stderr, "XXX: %s\n", __func__);
|
|
|
|
}
|
|
|
|
|
Rework how kgdb manages kernel and vmcore files to be a bit more gdb-ish
so that kgdb can be used more like a normal gdb:
- Load the kernel via the standard 'exec' target and allow it to be changed
via the 'file' command.
- Instead of explicitly loading the kernel file as the mail symbol file
during startup, just pass it to gdb_main() as the executable file.
- Change the kld support (via shared libraries) to cache the address of
the linker_files and linker_kernel_file variables in addition to the
offsets of various members in 'struct linker_file'.
- When a new symbol file is loaded, recompute the addresses and offsets
used by the kld support code.
- When a new symbol file is loaded, recalculate the ofs_fix variable to
account for the different ways a trapframe can be passed to trap
frame handlers in i386. This is done by adding a MD
kgdb_trgt_new_objfile() hook that is empty on all but i386.
- Don't use the directory name of the kernel specified on the command
line to find kernel modules in the kld support code. Instead,
extract the filename of the current executable via exec_bfd. Now
the 'kernel' variable is private to main.c again.
- Make the 'add-kld' command explicitly fail if no executable is loaded.
- Make the support for vmcores a real core-dump target that opens the
kernel and vmcore on open and closes the kvm connection when closed, etc.
- The 'core' command can now be used to select a vmcore to use, either
a crash dump file or /dev/mem for live debugging.
- The 'detach' command can be used to detach from a vmcore w/o attaching
to a new one.
- kgdb no longer explicitly opens a core dump during startup and no longer
has to use an atexit() hook to close the kvm connection on shutdown.
- Symbols for kld's are automatically loaded anytime a core is opened.
Also, the unread portion of dmesg is dumped just as it was done on kgdb
startup previously.
- Don't require either a remote target or core dump if a kernel is specified.
You can now just run 'kgdb kernel' similar to running gdb on an executable
and later connect to a remote target or core dump.
- Use a more relaxed way to verify remote targets specified via -r.
Instead of explicitly allowing a few non-file target specifications,
just assume that if stat() on the arg and on "/dev/" + arg both fail
that is some non-file target and pass it to gdb.
- Don't use a custom interpreter. The existing kgdb_init() hook and the
target_new_objfile() hook give us sufficient hooks during startup to
setup kgdb-specific behavior now.
- Always add the 'proc', 'tid', and 'add-kld' commands on startup and not
just if we have a core dump. Currently the 'proc' and 'tid' commands do
not work for remote targets (I will fix at least 'tid' in the next round
of changes though). However, the 'add-kld' command works fine for
loading symbols for a kernel module on a remote target.
- Always setup the 'kld' shared library target operations instead of just
if we have a core dump. Although symbols for kernel modules are not
automatically loaded when connecting to a remote target, you can do
'info sharedlibrary' after connecting to the remote target and kgdb will
find all the modules. You can then use the 'sharedlibrary' command to
load symbols from the module files.
- Change kthr_init() to free the existing list of kthr objects before
generating a new one. This allows it to be invoked multiple times
w/o leaking memory.
MFC after: 1 week
2008-04-29 20:32:45 +00:00
|
|
|
void
|
|
|
|
kgdb_trgt_new_objfile(struct objfile *objfile)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2006-09-14 07:51:52 +00:00
|
|
|
#ifndef CROSS_DEBUGGER
|
2006-07-22 15:27:18 +00:00
|
|
|
struct kgdb_frame_cache {
|
|
|
|
CORE_ADDR fp;
|
|
|
|
CORE_ADDR sp;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int kgdb_trgt_frame_offset[26] = {
|
|
|
|
offsetof(struct trapframe, tf_r0),
|
|
|
|
offsetof(struct trapframe, tf_r1),
|
|
|
|
offsetof(struct trapframe, tf_r2),
|
|
|
|
offsetof(struct trapframe, tf_r3),
|
|
|
|
offsetof(struct trapframe, tf_r4),
|
|
|
|
offsetof(struct trapframe, tf_r5),
|
|
|
|
offsetof(struct trapframe, tf_r6),
|
|
|
|
offsetof(struct trapframe, tf_r7),
|
|
|
|
offsetof(struct trapframe, tf_r8),
|
|
|
|
offsetof(struct trapframe, tf_r9),
|
|
|
|
offsetof(struct trapframe, tf_r10),
|
|
|
|
offsetof(struct trapframe, tf_r11),
|
|
|
|
offsetof(struct trapframe, tf_r12),
|
|
|
|
offsetof(struct trapframe, tf_svc_sp),
|
|
|
|
offsetof(struct trapframe, tf_svc_lr),
|
|
|
|
offsetof(struct trapframe, tf_pc),
|
|
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
|
|
offsetof(struct trapframe, tf_spsr)
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct kgdb_frame_cache *
|
|
|
|
kgdb_trgt_frame_cache(struct frame_info *next_frame, void **this_cache)
|
|
|
|
{
|
|
|
|
char buf[MAX_REGISTER_SIZE];
|
|
|
|
struct kgdb_frame_cache *cache;
|
|
|
|
|
|
|
|
cache = *this_cache;
|
|
|
|
if (cache == NULL) {
|
|
|
|
cache = FRAME_OBSTACK_ZALLOC(struct kgdb_frame_cache);
|
|
|
|
*this_cache = cache;
|
|
|
|
frame_unwind_register(next_frame, ARM_SP_REGNUM, buf);
|
|
|
|
cache->sp = extract_unsigned_integer(buf,
|
|
|
|
register_size(current_gdbarch, ARM_SP_REGNUM));
|
|
|
|
frame_unwind_register(next_frame, ARM_FP_REGNUM, buf);
|
|
|
|
cache->fp = extract_unsigned_integer(buf,
|
|
|
|
register_size(current_gdbarch, ARM_FP_REGNUM));
|
|
|
|
}
|
|
|
|
return (cache);
|
|
|
|
}
|
|
|
|
|
2006-09-14 07:51:52 +00:00
|
|
|
static int is_undef;
|
|
|
|
|
2006-07-22 15:27:18 +00:00
|
|
|
static void
|
|
|
|
kgdb_trgt_trapframe_this_id(struct frame_info *next_frame, void **this_cache,
|
|
|
|
struct frame_id *this_id)
|
|
|
|
{
|
|
|
|
struct kgdb_frame_cache *cache;
|
|
|
|
|
|
|
|
cache = kgdb_trgt_frame_cache(next_frame, this_cache);
|
|
|
|
*this_id = frame_id_build(cache->fp, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
kgdb_trgt_trapframe_prev_register(struct frame_info *next_frame,
|
|
|
|
void **this_cache, int regnum, int *optimizedp, enum lval_type *lvalp,
|
|
|
|
CORE_ADDR *addrp, int *realnump, void *valuep)
|
|
|
|
{
|
|
|
|
char dummy_valuep[MAX_REGISTER_SIZE];
|
|
|
|
struct kgdb_frame_cache *cache;
|
|
|
|
int ofs, regsz;
|
2006-09-14 07:51:52 +00:00
|
|
|
int is_undefined = 0;
|
2006-07-22 15:27:18 +00:00
|
|
|
|
|
|
|
regsz = register_size(current_gdbarch, regnum);
|
|
|
|
|
|
|
|
if (valuep == NULL)
|
|
|
|
valuep = dummy_valuep;
|
|
|
|
memset(valuep, 0, regsz);
|
|
|
|
*optimizedp = 0;
|
|
|
|
*addrp = 0;
|
|
|
|
*lvalp = not_lval;
|
|
|
|
*realnump = -1;
|
|
|
|
|
|
|
|
ofs = (regnum >= 0 && regnum <= ARM_PS_REGNUM)
|
|
|
|
? kgdb_trgt_frame_offset[regnum] : -1;
|
|
|
|
if (ofs == -1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
cache = kgdb_trgt_frame_cache(next_frame, this_cache);
|
2006-10-16 20:07:23 +00:00
|
|
|
|
2006-09-14 07:51:52 +00:00
|
|
|
if (is_undef && (regnum == ARM_SP_REGNUM || regnum == ARM_PC_REGNUM)) {
|
|
|
|
*addrp = cache->sp + offsetof(struct trapframe, tf_spsr);
|
|
|
|
target_read_memory(*addrp, valuep, regsz);
|
|
|
|
is_undefined = 1;
|
|
|
|
ofs = kgdb_trgt_frame_offset[ARM_SP_REGNUM];
|
|
|
|
|
|
|
|
}
|
2006-07-22 15:27:18 +00:00
|
|
|
*addrp = cache->sp + ofs;
|
|
|
|
*lvalp = lval_memory;
|
|
|
|
target_read_memory(*addrp, valuep, regsz);
|
2006-09-14 07:51:52 +00:00
|
|
|
|
|
|
|
if (is_undefined) {
|
|
|
|
*addrp = *(unsigned int *)valuep + (regnum == ARM_SP_REGNUM ?
|
|
|
|
0 : 8);
|
|
|
|
target_read_memory(*addrp, valuep, regsz);
|
|
|
|
|
|
|
|
}
|
2006-07-22 15:27:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct frame_unwind kgdb_trgt_trapframe_unwind = {
|
|
|
|
UNKNOWN_FRAME,
|
|
|
|
&kgdb_trgt_trapframe_this_id,
|
|
|
|
&kgdb_trgt_trapframe_prev_register
|
|
|
|
};
|
2006-09-14 07:51:52 +00:00
|
|
|
#endif
|
2006-07-22 15:27:18 +00:00
|
|
|
|
|
|
|
const struct frame_unwind *
|
|
|
|
kgdb_trgt_trapframe_sniffer(struct frame_info *next_frame)
|
|
|
|
{
|
2006-09-14 07:51:52 +00:00
|
|
|
#ifndef CROSS_DEBUGGER
|
2006-07-22 15:27:18 +00:00
|
|
|
char *pname;
|
|
|
|
CORE_ADDR pc;
|
|
|
|
|
|
|
|
pc = frame_pc_unwind(next_frame);
|
|
|
|
pname = NULL;
|
|
|
|
find_pc_partial_function(pc, &pname, NULL, NULL);
|
2006-09-14 07:51:52 +00:00
|
|
|
if (pname == NULL) {
|
|
|
|
is_undef = 0;
|
2006-07-22 15:27:18 +00:00
|
|
|
return (NULL);
|
2006-09-14 07:51:52 +00:00
|
|
|
}
|
|
|
|
if (!strcmp(pname, "undefinedinstruction"))
|
|
|
|
is_undef = 1;
|
2006-07-22 15:27:18 +00:00
|
|
|
if (strcmp(pname, "Laddress_exception_entry") == 0 ||
|
|
|
|
strcmp(pname, "undefined_entry") == 0 ||
|
|
|
|
strcmp(pname, "exception_exit") == 0 ||
|
2006-09-14 07:51:52 +00:00
|
|
|
strcmp(pname, "Laddress_exception_msg") == 0 ||
|
2006-07-22 15:27:18 +00:00
|
|
|
strcmp(pname, "irq_entry") == 0)
|
|
|
|
return (&kgdb_trgt_trapframe_unwind);
|
2006-09-14 07:51:52 +00:00
|
|
|
if (!strcmp(pname, "undefinedinstruction"))
|
|
|
|
is_undef = 1;
|
|
|
|
else
|
|
|
|
is_undef = 0;
|
|
|
|
#endif
|
2006-07-22 15:27:18 +00:00
|
|
|
return (NULL);
|
|
|
|
}
|