d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
freebsd-skq/gnu/usr.bin/gdb/kgdb/trgt.c

355 lines
8.5 KiB
C
Raw Normal View History

Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +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 AUTHOR ``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 AUTHOR 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$");
Attempt to make kgdb little more useful and easy to use. Properly initialize it to recognise what ABI to use on amd64 (and possibly others) platform. Display PID and process name as a part of the 'info threads' output, TIDs alone are too confusing. Introduce new commmands 'tid <tid>' and 'proc <pid>' to accompany gdb's default 'thread <thread num>' to make the task of switching between different contexts easier.
2005-02-20 22:55:07 +00:00
#include <sys/param.h>
#include <sys/proc.h>
#include <sys/sysctl.h>
#include <sys/user.h>
Don't close the kernel bfd object during startup. Instead, leave it open and build a section table from the kernel file so that 'info files' output for kgdb now matches the usage of gdb on a regular file with the exception that we don't list sections for memory in the crash dump.
2008-01-29 23:37:59 +00:00
#include <err.h>
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
#include <fcntl.h>
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
#include <kvm.h>
#include <defs.h>
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
#include <readline/readline.h>
#include <readline/tilde.h>
Attempt to make kgdb little more useful and easy to use. Properly initialize it to recognise what ABI to use on amd64 (and possibly others) platform. Display PID and process name as a part of the 'info threads' output, TIDs alone are too confusing. Introduce new commmands 'tid <tid>' and 'proc <pid>' to accompany gdb's default 'thread <thread num>' to make the task of switching between different contexts easier.
2005-02-20 22:55:07 +00:00
#include <command.h>
Don't close the kernel bfd object during startup. Instead, leave it open and build a section table from the kernel file so that 'info files' output for kgdb now matches the usage of gdb on a regular file with the exception that we don't list sections for memory in the crash dump.
2008-01-29 23:37:59 +00:00
#include <exec.h>
Add a kluge to allow kgdb(1) to inject its own frame sniffer in the list of frame sniffers so that trapframes can be detected. The kluge is needed because this version of gdb only supports appending a sniffer to the list of sniffers and the moment kgdb gets a chance to add its own frame sniffer, the target's default frame sniffer is already in the list. Since the default frame sniffer claims any frame thrown at it, kgdb's frame sniffer never gets to smell (a process much akin to tasting, but with lesser chance of hurling :-) This commit adds dummy frame sniffers that never claim a frame and as such don't fix anything yet. However, we now have frame sniffers and they are being called, so it's just a matter of adding meat to the bones and we'll be able to properly unwind across trapframes. MFC after: 1 week
2005-09-10 18:25:53 +00:00
#include <frame-unwind.h>
- Change how the vmcore target maps FreeBSD thread IDs to GDB ptids. We now only use the TID and ignore the PID and use pid_to_ptid() to build a ptid treating the TID as a PID. The benefit of this is that the vmcore target now uses the same scheme as GDB's remote targets. As a result, the 'tid' command now works for remote targets (however, it only accepts TIDs and not addresses of 'struct thread' objects). - Use gdb_thread_select() to do the actual thread switch for the 'tid' and 'proc' commands. This now gives the same UI feedback when switching threads as the GDB 'thread' command rather than providing no visual output at all. MFC after: 1 week
2008-05-01 20:36:48 +00:00
#include <gdb.h>
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
#include <gdbcore.h>
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
#include <gdbthread.h>
#include <inferior.h>
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
#include <language.h>
Attempt to make kgdb little more useful and easy to use. Properly initialize it to recognise what ABI to use on amd64 (and possibly others) platform. Display PID and process name as a part of the 'info threads' output, TIDs alone are too confusing. Introduce new commmands 'tid <tid>' and 'proc <pid>' to accompany gdb's default 'thread <thread num>' to make the task of switching between different contexts easier.
2005-02-20 22:55:07 +00:00
#include <regcache.h>
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
#include <solib.h>
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
#include <target.h>
- Change how the vmcore target maps FreeBSD thread IDs to GDB ptids. We now only use the TID and ignore the PID and use pid_to_ptid() to build a ptid treating the TID as a PID. The benefit of this is that the vmcore target now uses the same scheme as GDB's remote targets. As a result, the 'tid' command now works for remote targets (however, it only accepts TIDs and not addresses of 'struct thread' objects). - Use gdb_thread_select() to do the actual thread switch for the 'tid' and 'proc' commands. This now gives the same UI feedback when switching threads as the GDB 'thread' command rather than providing no visual output at all. MFC after: 1 week
2008-05-01 20:36:48 +00:00
#include <ui-out.h>
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
Attempt to make kgdb little more useful and easy to use. Properly initialize it to recognise what ABI to use on amd64 (and possibly others) platform. Display PID and process name as a part of the 'info threads' output, TIDs alone are too confusing. Introduce new commmands 'tid <tid>' and 'proc <pid>' to accompany gdb's default 'thread <thread num>' to make the task of switching between different contexts easier.
2005-02-20 22:55:07 +00:00
#include "kgdb.h"
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
static void kgdb_core_cleanup(void *);
static char *vmcore;
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
static struct target_ops kgdb_trgt_ops;
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
kvm_t *kvm;
static char kvm_err[_POSIX2_LINE_MAX];
Don't close the kernel bfd object during startup. Instead, leave it open and build a section table from the kernel file so that 'info files' output for kgdb now matches the usage of gdb on a regular file with the exception that we don't list sections for memory in the crash dump.
2008-01-29 23:37:59 +00:00
Restore the 'proc' and 'tid' commands which allow one to switch to the first thread in a process or to a specific thread via PIDs and TIDs, respectively. Submitted by: kan Approved by: marcel
2006-10-16 20:06:32 +00:00
#define KERNOFF (kgdb_kernbase ())
#define INKERNEL(x) ((x) >= KERNOFF)
static CORE_ADDR
kgdb_kernbase (void)
{
static CORE_ADDR kernbase;
struct minimal_symbol *sym;
if (kernbase == 0) {
sym = lookup_minimal_symbol ("kernbase", NULL, NULL);
if (sym == NULL) {
kernbase = KERNBASE;
} else {
kernbase = SYMBOL_VALUE_ADDRESS (sym);
}
}
return kernbase;
}
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
static void
kgdb_trgt_open(char *filename, int from_tty)
{
struct cleanup *old_chain;
struct thread_info *ti;
struct kthr *kt;
kvm_t *nkvm;
char *temp;
int ontop;
target_preopen (from_tty);
if (!filename)
error ("No vmcore file specified.");
if (!exec_bfd)
error ("Can't open a vmcore without a kernel");
filename = tilde_expand (filename);
if (filename[0] != '/') {
temp = concat (current_directory, "/", filename, NULL);
xfree(filename);
filename = temp;
}
old_chain = make_cleanup (xfree, filename);
nkvm = kvm_openfiles(bfd_get_filename(exec_bfd), filename, NULL,
write_files ? O_RDWR : O_RDONLY, kvm_err);
if (nkvm == NULL)
error ("Failed to open vmcore: %s", kvm_err);
/* Don't free the filename now and close any previous vmcore. */
discard_cleanups(old_chain);
unpush_target(&kgdb_trgt_ops);
kvm = nkvm;
vmcore = filename;
old_chain = make_cleanup(kgdb_core_cleanup, NULL);
ontop = !push_target (&kgdb_trgt_ops);
discard_cleanups (old_chain);
kgdb_dmesg();
init_thread_list();
kt = kgdb_thr_init();
while (kt != NULL) {
- Change how the vmcore target maps FreeBSD thread IDs to GDB ptids. We now only use the TID and ignore the PID and use pid_to_ptid() to build a ptid treating the TID as a PID. The benefit of this is that the vmcore target now uses the same scheme as GDB's remote targets. As a result, the 'tid' command now works for remote targets (however, it only accepts TIDs and not addresses of 'struct thread' objects). - Use gdb_thread_select() to do the actual thread switch for the 'tid' and 'proc' commands. This now gives the same UI feedback when switching threads as the GDB 'thread' command rather than providing no visual output at all. MFC after: 1 week
2008-05-01 20:36:48 +00:00
ti = add_thread(pid_to_ptid(kt->tid));
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
kt = kgdb_thr_next(kt);
}
if (curkthr != 0)
- Change how the vmcore target maps FreeBSD thread IDs to GDB ptids. We now only use the TID and ignore the PID and use pid_to_ptid() to build a ptid treating the TID as a PID. The benefit of this is that the vmcore target now uses the same scheme as GDB's remote targets. As a result, the 'tid' command now works for remote targets (however, it only accepts TIDs and not addresses of 'struct thread' objects). - Use gdb_thread_select() to do the actual thread switch for the 'tid' and 'proc' commands. This now gives the same UI feedback when switching threads as the GDB 'thread' command rather than providing no visual output at all. MFC after: 1 week
2008-05-01 20:36:48 +00:00
inferior_ptid = pid_to_ptid(curkthr->tid);
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
if (ontop) {
/* XXX: fetch registers? */
kld_init();
flush_cached_frames();
select_frame (get_current_frame());
print_stack_frame(get_selected_frame(),
frame_relative_level(get_selected_frame()), 1);
} else
warning(
"you won't be able to access this vmcore until you terminate\n\
your %s; do ``info files''", target_longname);
}
static void
kgdb_trgt_close(int quitting)
{
if (kvm != NULL) {
inferior_ptid = null_ptid;
CLEAR_SOLIB();
if (kvm_close(kvm) != 0)
warning("cannot close \"%s\": %s", vmcore,
kvm_geterr(kvm));
kvm = NULL;
xfree(vmcore);
vmcore = NULL;
if (kgdb_trgt_ops.to_sections) {
xfree(kgdb_trgt_ops.to_sections);
kgdb_trgt_ops.to_sections = NULL;
kgdb_trgt_ops.to_sections_end = NULL;
}
}
}
static void
kgdb_core_cleanup(void *arg)
{
kgdb_trgt_close(0);
}
static void
kgdb_trgt_detach(char *args, int from_tty)
{
if (args)
error ("Too many arguments");
unpush_target(&kgdb_trgt_ops);
reinit_frame_cache();
if (from_tty)
printf_filtered("No vmcore file now.\n");
}
o Remove the obscure tid command, because it does what the thread command does, but worse. o Remove the obscure proc command, because it does what the thread command does, but not unambigously. o Move the PID to the extra thread info, where it makes sense and where it doesn't confuse users. The extra thread info holds some process information, to which the PID belongs. o Implement the to_find_new_threads target method by having it call the target beneath us if we're not using KVM. This makes sure that new threads are found when using the remote target. o Fix various core dump scenarios: - Implement the to_files_info target method. Previously the 'info target' command would cause a NULL pointer dereference. - Don't assume there's a current thread. We're not initialized in all cases. This prevents a NULL pointer dereference. - When we're not ussing KVM, have the to_xfer_memory target method call the target beneath us. This avoids calling into KVM with a NULL pointer. MFC after: 1 week
2005-08-06 19:22:27 +00:00
static char *
kgdb_trgt_extra_thread_info(struct thread_info *ti)
Attempt to make kgdb little more useful and easy to use. Properly initialize it to recognise what ABI to use on amd64 (and possibly others) platform. Display PID and process name as a part of the 'info threads' output, TIDs alone are too confusing. Introduce new commmands 'tid <tid>' and 'proc <pid>' to accompany gdb's default 'thread <thread num>' to make the task of switching between different contexts easier.
2005-02-20 22:55:07 +00:00
{
o Remove the obscure tid command, because it does what the thread command does, but worse. o Remove the obscure proc command, because it does what the thread command does, but not unambigously. o Move the PID to the extra thread info, where it makes sense and where it doesn't confuse users. The extra thread info holds some process information, to which the PID belongs. o Implement the to_find_new_threads target method by having it call the target beneath us if we're not using KVM. This makes sure that new threads are found when using the remote target. o Fix various core dump scenarios: - Implement the to_files_info target method. Previously the 'info target' command would cause a NULL pointer dereference. - Don't assume there's a current thread. We're not initialized in all cases. This prevents a NULL pointer dereference. - When we're not ussing KVM, have the to_xfer_memory target method call the target beneath us. This avoids calling into KVM with a NULL pointer. MFC after: 1 week
2005-08-06 19:22:27 +00:00
- Change how the vmcore target maps FreeBSD thread IDs to GDB ptids. We now only use the TID and ignore the PID and use pid_to_ptid() to build a ptid treating the TID as a PID. The benefit of this is that the vmcore target now uses the same scheme as GDB's remote targets. As a result, the 'tid' command now works for remote targets (however, it only accepts TIDs and not addresses of 'struct thread' objects). - Use gdb_thread_select() to do the actual thread switch for the 'tid' and 'proc' commands. This now gives the same UI feedback when switching threads as the GDB 'thread' command rather than providing no visual output at all. MFC after: 1 week
2008-05-01 20:36:48 +00:00
return (kgdb_thr_extra_thread_info(ptid_get_pid(ti->ptid)));
Attempt to make kgdb little more useful and easy to use. Properly initialize it to recognise what ABI to use on amd64 (and possibly others) platform. Display PID and process name as a part of the 'info threads' output, TIDs alone are too confusing. Introduce new commmands 'tid <tid>' and 'proc <pid>' to accompany gdb's default 'thread <thread num>' to make the task of switching between different contexts easier.
2005-02-20 22:55:07 +00:00
}
o Remove the obscure tid command, because it does what the thread command does, but worse. o Remove the obscure proc command, because it does what the thread command does, but not unambigously. o Move the PID to the extra thread info, where it makes sense and where it doesn't confuse users. The extra thread info holds some process information, to which the PID belongs. o Implement the to_find_new_threads target method by having it call the target beneath us if we're not using KVM. This makes sure that new threads are found when using the remote target. o Fix various core dump scenarios: - Implement the to_files_info target method. Previously the 'info target' command would cause a NULL pointer dereference. - Don't assume there's a current thread. We're not initialized in all cases. This prevents a NULL pointer dereference. - When we're not ussing KVM, have the to_xfer_memory target method call the target beneath us. This avoids calling into KVM with a NULL pointer. MFC after: 1 week
2005-08-06 19:22:27 +00:00
static void
kgdb_trgt_files_info(struct target_ops *target)
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
{
o Remove the obscure tid command, because it does what the thread command does, but worse. o Remove the obscure proc command, because it does what the thread command does, but not unambigously. o Move the PID to the extra thread info, where it makes sense and where it doesn't confuse users. The extra thread info holds some process information, to which the PID belongs. o Implement the to_find_new_threads target method by having it call the target beneath us if we're not using KVM. This makes sure that new threads are found when using the remote target. o Fix various core dump scenarios: - Implement the to_files_info target method. Previously the 'info target' command would cause a NULL pointer dereference. - Don't assume there's a current thread. We're not initialized in all cases. This prevents a NULL pointer dereference. - When we're not ussing KVM, have the to_xfer_memory target method call the target beneath us. This avoids calling into KVM with a NULL pointer. MFC after: 1 week
2005-08-06 19:22:27 +00:00
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
printf_filtered ("\t`%s', ", vmcore);
wrap_here (" ");
printf_filtered ("file type %s.\n", "FreeBSD kernel vmcore");
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
}
static void
kgdb_trgt_find_new_threads(void)
{
o Remove the obscure tid command, because it does what the thread command does, but worse. o Remove the obscure proc command, because it does what the thread command does, but not unambigously. o Move the PID to the extra thread info, where it makes sense and where it doesn't confuse users. The extra thread info holds some process information, to which the PID belongs. o Implement the to_find_new_threads target method by having it call the target beneath us if we're not using KVM. This makes sure that new threads are found when using the remote target. o Fix various core dump scenarios: - Implement the to_files_info target method. Previously the 'info target' command would cause a NULL pointer dereference. - Don't assume there's a current thread. We're not initialized in all cases. This prevents a NULL pointer dereference. - When we're not ussing KVM, have the to_xfer_memory target method call the target beneath us. This avoids calling into KVM with a NULL pointer. MFC after: 1 week
2005-08-06 19:22:27 +00:00
struct target_ops *tb;
if (kvm != NULL)
return;
tb = find_target_beneath(&kgdb_trgt_ops);
if (tb->to_find_new_threads != NULL)
tb->to_find_new_threads();
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
}
static char *
kgdb_trgt_pid_to_str(ptid_t ptid)
{
Attempt to make kgdb little more useful and easy to use. Properly initialize it to recognise what ABI to use on amd64 (and possibly others) platform. Display PID and process name as a part of the 'info threads' output, TIDs alone are too confusing. Introduce new commmands 'tid <tid>' and 'proc <pid>' to accompany gdb's default 'thread <thread num>' to make the task of switching between different contexts easier.
2005-02-20 22:55:07 +00:00
static char buf[33];
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
- Change how the vmcore target maps FreeBSD thread IDs to GDB ptids. We now only use the TID and ignore the PID and use pid_to_ptid() to build a ptid treating the TID as a PID. The benefit of this is that the vmcore target now uses the same scheme as GDB's remote targets. As a result, the 'tid' command now works for remote targets (however, it only accepts TIDs and not addresses of 'struct thread' objects). - Use gdb_thread_select() to do the actual thread switch for the 'tid' and 'proc' commands. This now gives the same UI feedback when switching threads as the GDB 'thread' command rather than providing no visual output at all. MFC after: 1 week
2008-05-01 20:36:48 +00:00
snprintf(buf, sizeof(buf), "Thread %d", ptid_get_pid(ptid));
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
return (buf);
}
static int
kgdb_trgt_thread_alive(ptid_t ptid)
{
- Change how the vmcore target maps FreeBSD thread IDs to GDB ptids. We now only use the TID and ignore the PID and use pid_to_ptid() to build a ptid treating the TID as a PID. The benefit of this is that the vmcore target now uses the same scheme as GDB's remote targets. As a result, the 'tid' command now works for remote targets (however, it only accepts TIDs and not addresses of 'struct thread' objects). - Use gdb_thread_select() to do the actual thread switch for the 'tid' and 'proc' commands. This now gives the same UI feedback when switching threads as the GDB 'thread' command rather than providing no visual output at all. MFC after: 1 week
2008-05-01 20:36:48 +00:00
return (kgdb_thr_lookup_tid(ptid_get_pid(ptid)) != NULL);
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
}
static int
kgdb_trgt_xfer_memory(CORE_ADDR memaddr, char *myaddr, int len, int write,
o Remove the obscure tid command, because it does what the thread command does, but worse. o Remove the obscure proc command, because it does what the thread command does, but not unambigously. o Move the PID to the extra thread info, where it makes sense and where it doesn't confuse users. The extra thread info holds some process information, to which the PID belongs. o Implement the to_find_new_threads target method by having it call the target beneath us if we're not using KVM. This makes sure that new threads are found when using the remote target. o Fix various core dump scenarios: - Implement the to_files_info target method. Previously the 'info target' command would cause a NULL pointer dereference. - Don't assume there's a current thread. We're not initialized in all cases. This prevents a NULL pointer dereference. - When we're not ussing KVM, have the to_xfer_memory target method call the target beneath us. This avoids calling into KVM with a NULL pointer. MFC after: 1 week
2005-08-06 19:22:27 +00:00
struct mem_attrib *attrib, struct target_ops *target)
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
{
o Remove the obscure tid command, because it does what the thread command does, but worse. o Remove the obscure proc command, because it does what the thread command does, but not unambigously. o Move the PID to the extra thread info, where it makes sense and where it doesn't confuse users. The extra thread info holds some process information, to which the PID belongs. o Implement the to_find_new_threads target method by having it call the target beneath us if we're not using KVM. This makes sure that new threads are found when using the remote target. o Fix various core dump scenarios: - Implement the to_files_info target method. Previously the 'info target' command would cause a NULL pointer dereference. - Don't assume there's a current thread. We're not initialized in all cases. This prevents a NULL pointer dereference. - When we're not ussing KVM, have the to_xfer_memory target method call the target beneath us. This avoids calling into KVM with a NULL pointer. MFC after: 1 week
2005-08-06 19:22:27 +00:00
struct target_ops *tb;
if (kvm != NULL) {
if (len == 0)
return (0);
if (!write)
return (kvm_read(kvm, memaddr, myaddr, len));
else
return (kvm_write(kvm, memaddr, myaddr, len));
Attempt to make kgdb little more useful and easy to use. Properly initialize it to recognise what ABI to use on amd64 (and possibly others) platform. Display PID and process name as a part of the 'info threads' output, TIDs alone are too confusing. Introduce new commmands 'tid <tid>' and 'proc <pid>' to accompany gdb's default 'thread <thread num>' to make the task of switching between different contexts easier.
2005-02-20 22:55:07 +00:00
}
o Remove the obscure tid command, because it does what the thread command does, but worse. o Remove the obscure proc command, because it does what the thread command does, but not unambigously. o Move the PID to the extra thread info, where it makes sense and where it doesn't confuse users. The extra thread info holds some process information, to which the PID belongs. o Implement the to_find_new_threads target method by having it call the target beneath us if we're not using KVM. This makes sure that new threads are found when using the remote target. o Fix various core dump scenarios: - Implement the to_files_info target method. Previously the 'info target' command would cause a NULL pointer dereference. - Don't assume there's a current thread. We're not initialized in all cases. This prevents a NULL pointer dereference. - When we're not ussing KVM, have the to_xfer_memory target method call the target beneath us. This avoids calling into KVM with a NULL pointer. MFC after: 1 week
2005-08-06 19:22:27 +00:00
tb = find_target_beneath(target);
return (tb->to_xfer_memory(memaddr, myaddr, len, write, attrib, tb));
Attempt to make kgdb little more useful and easy to use. Properly initialize it to recognise what ABI to use on amd64 (and possibly others) platform. Display PID and process name as a part of the 'info threads' output, TIDs alone are too confusing. Introduce new commmands 'tid <tid>' and 'proc <pid>' to accompany gdb's default 'thread <thread num>' to make the task of switching between different contexts easier.
2005-02-20 22:55:07 +00:00
}
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
static int
kgdb_trgt_ignore_breakpoints(CORE_ADDR addr, char *contents)
{
return 0;
}
Restore the 'proc' and 'tid' commands which allow one to switch to the first thread in a process or to a specific thread via PIDs and TIDs, respectively. Submitted by: kan Approved by: marcel
2006-10-16 20:06:32 +00:00
static void
- Change how the vmcore target maps FreeBSD thread IDs to GDB ptids. We now only use the TID and ignore the PID and use pid_to_ptid() to build a ptid treating the TID as a PID. The benefit of this is that the vmcore target now uses the same scheme as GDB's remote targets. As a result, the 'tid' command now works for remote targets (however, it only accepts TIDs and not addresses of 'struct thread' objects). - Use gdb_thread_select() to do the actual thread switch for the 'tid' and 'proc' commands. This now gives the same UI feedback when switching threads as the GDB 'thread' command rather than providing no visual output at all. MFC after: 1 week
2008-05-01 20:36:48 +00:00
kgdb_switch_to_thread(int tid)
Restore the 'proc' and 'tid' commands which allow one to switch to the first thread in a process or to a specific thread via PIDs and TIDs, respectively. Submitted by: kan Approved by: marcel
2006-10-16 20:06:32 +00:00
{
- Change how the vmcore target maps FreeBSD thread IDs to GDB ptids. We now only use the TID and ignore the PID and use pid_to_ptid() to build a ptid treating the TID as a PID. The benefit of this is that the vmcore target now uses the same scheme as GDB's remote targets. As a result, the 'tid' command now works for remote targets (however, it only accepts TIDs and not addresses of 'struct thread' objects). - Use gdb_thread_select() to do the actual thread switch for the 'tid' and 'proc' commands. This now gives the same UI feedback when switching threads as the GDB 'thread' command rather than providing no visual output at all. MFC after: 1 week
2008-05-01 20:36:48 +00:00
char buf[16];
int thread_id;
thread_id = pid_to_thread_id(pid_to_ptid(tid));
if (thread_id == 0)
error ("invalid tid");
snprintf(buf, sizeof(buf), "%d", thread_id);
gdb_thread_select(uiout, buf);
Restore the 'proc' and 'tid' commands which allow one to switch to the first thread in a process or to a specific thread via PIDs and TIDs, respectively. Submitted by: kan Approved by: marcel
2006-10-16 20:06:32 +00:00
}
static void
kgdb_set_proc_cmd (char *arg, int from_tty)
{
CORE_ADDR addr;
struct kthr *thr;
if (!arg)
error_no_arg ("proc address for the new context");
if (kvm == NULL)
- Change how the vmcore target maps FreeBSD thread IDs to GDB ptids. We now only use the TID and ignore the PID and use pid_to_ptid() to build a ptid treating the TID as a PID. The benefit of this is that the vmcore target now uses the same scheme as GDB's remote targets. As a result, the 'tid' command now works for remote targets (however, it only accepts TIDs and not addresses of 'struct thread' objects). - Use gdb_thread_select() to do the actual thread switch for the 'tid' and 'proc' commands. This now gives the same UI feedback when switching threads as the GDB 'thread' command rather than providing no visual output at all. MFC after: 1 week
2008-05-01 20:36:48 +00:00
error ("only supported for core file target");
Restore the 'proc' and 'tid' commands which allow one to switch to the first thread in a process or to a specific thread via PIDs and TIDs, respectively. Submitted by: kan Approved by: marcel
2006-10-16 20:06:32 +00:00
addr = (CORE_ADDR) parse_and_eval_address (arg);
if (!INKERNEL (addr)) {
thr = kgdb_thr_lookup_pid((int)addr);
if (thr == NULL)
error ("invalid pid");
} else {
thr = kgdb_thr_lookup_paddr(addr);
if (thr == NULL)
error("invalid proc address");
}
- Change how the vmcore target maps FreeBSD thread IDs to GDB ptids. We now only use the TID and ignore the PID and use pid_to_ptid() to build a ptid treating the TID as a PID. The benefit of this is that the vmcore target now uses the same scheme as GDB's remote targets. As a result, the 'tid' command now works for remote targets (however, it only accepts TIDs and not addresses of 'struct thread' objects). - Use gdb_thread_select() to do the actual thread switch for the 'tid' and 'proc' commands. This now gives the same UI feedback when switching threads as the GDB 'thread' command rather than providing no visual output at all. MFC after: 1 week
2008-05-01 20:36:48 +00:00
kgdb_switch_to_thread(thr->tid);
Restore the 'proc' and 'tid' commands which allow one to switch to the first thread in a process or to a specific thread via PIDs and TIDs, respectively. Submitted by: kan Approved by: marcel
2006-10-16 20:06:32 +00:00
}
static void
kgdb_set_tid_cmd (char *arg, int from_tty)
{
CORE_ADDR addr;
struct kthr *thr;
if (!arg)
error_no_arg ("TID or thread address for the new context");
addr = (CORE_ADDR) parse_and_eval_address (arg);
- Change how the vmcore target maps FreeBSD thread IDs to GDB ptids. We now only use the TID and ignore the PID and use pid_to_ptid() to build a ptid treating the TID as a PID. The benefit of this is that the vmcore target now uses the same scheme as GDB's remote targets. As a result, the 'tid' command now works for remote targets (however, it only accepts TIDs and not addresses of 'struct thread' objects). - Use gdb_thread_select() to do the actual thread switch for the 'tid' and 'proc' commands. This now gives the same UI feedback when switching threads as the GDB 'thread' command rather than providing no visual output at all. MFC after: 1 week
2008-05-01 20:36:48 +00:00
if (kvm != NULL && INKERNEL (addr)) {
Restore the 'proc' and 'tid' commands which allow one to switch to the first thread in a process or to a specific thread via PIDs and TIDs, respectively. Submitted by: kan Approved by: marcel
2006-10-16 20:06:32 +00:00
thr = kgdb_thr_lookup_taddr(addr);
if (thr == NULL)
error("invalid thread address");
- Change how the vmcore target maps FreeBSD thread IDs to GDB ptids. We now only use the TID and ignore the PID and use pid_to_ptid() to build a ptid treating the TID as a PID. The benefit of this is that the vmcore target now uses the same scheme as GDB's remote targets. As a result, the 'tid' command now works for remote targets (however, it only accepts TIDs and not addresses of 'struct thread' objects). - Use gdb_thread_select() to do the actual thread switch for the 'tid' and 'proc' commands. This now gives the same UI feedback when switching threads as the GDB 'thread' command rather than providing no visual output at all. MFC after: 1 week
2008-05-01 20:36:48 +00:00
addr = thr->tid;
Restore the 'proc' and 'tid' commands which allow one to switch to the first thread in a process or to a specific thread via PIDs and TIDs, respectively. Submitted by: kan Approved by: marcel
2006-10-16 20:06:32 +00:00
}
- Change how the vmcore target maps FreeBSD thread IDs to GDB ptids. We now only use the TID and ignore the PID and use pid_to_ptid() to build a ptid treating the TID as a PID. The benefit of this is that the vmcore target now uses the same scheme as GDB's remote targets. As a result, the 'tid' command now works for remote targets (however, it only accepts TIDs and not addresses of 'struct thread' objects). - Use gdb_thread_select() to do the actual thread switch for the 'tid' and 'proc' commands. This now gives the same UI feedback when switching threads as the GDB 'thread' command rather than providing no visual output at all. MFC after: 1 week
2008-05-01 20:36:48 +00:00
kgdb_switch_to_thread(addr);
Restore the 'proc' and 'tid' commands which allow one to switch to the first thread in a process or to a specific thread via PIDs and TIDs, respectively. Submitted by: kan Approved by: marcel
2006-10-16 20:06:32 +00:00
}
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
int fbsdcoreops_suppress_target = 1;
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
void
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
initialize_kgdb_target(void)
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
{
kgdb_trgt_ops.to_magic = OPS_MAGIC;
kgdb_trgt_ops.to_shortname = "kernel";
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
kgdb_trgt_ops.to_longname = "kernel core dump file";
kgdb_trgt_ops.to_doc =
"Use a vmcore file as a target. Specify the filename of the vmcore file.";
kgdb_trgt_ops.to_stratum = core_stratum;
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
kgdb_trgt_ops.to_has_memory = 1;
kgdb_trgt_ops.to_has_registers = 1;
kgdb_trgt_ops.to_has_stack = 1;
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
kgdb_trgt_ops.to_open = kgdb_trgt_open;
kgdb_trgt_ops.to_close = kgdb_trgt_close;
kgdb_trgt_ops.to_attach = find_default_attach;
kgdb_trgt_ops.to_detach = kgdb_trgt_detach;
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
kgdb_trgt_ops.to_extra_thread_info = kgdb_trgt_extra_thread_info;
kgdb_trgt_ops.to_fetch_registers = kgdb_trgt_fetch_registers;
o Remove the obscure tid command, because it does what the thread command does, but worse. o Remove the obscure proc command, because it does what the thread command does, but not unambigously. o Move the PID to the extra thread info, where it makes sense and where it doesn't confuse users. The extra thread info holds some process information, to which the PID belongs. o Implement the to_find_new_threads target method by having it call the target beneath us if we're not using KVM. This makes sure that new threads are found when using the remote target. o Fix various core dump scenarios: - Implement the to_files_info target method. Previously the 'info target' command would cause a NULL pointer dereference. - Don't assume there's a current thread. We're not initialized in all cases. This prevents a NULL pointer dereference. - When we're not ussing KVM, have the to_xfer_memory target method call the target beneath us. This avoids calling into KVM with a NULL pointer. MFC after: 1 week
2005-08-06 19:22:27 +00:00
kgdb_trgt_ops.to_files_info = kgdb_trgt_files_info;
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
kgdb_trgt_ops.to_find_new_threads = kgdb_trgt_find_new_threads;
kgdb_trgt_ops.to_pid_to_str = kgdb_trgt_pid_to_str;
kgdb_trgt_ops.to_store_registers = kgdb_trgt_store_registers;
kgdb_trgt_ops.to_thread_alive = kgdb_trgt_thread_alive;
kgdb_trgt_ops.to_xfer_memory = kgdb_trgt_xfer_memory;
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
kgdb_trgt_ops.to_insert_breakpoint = kgdb_trgt_ignore_breakpoints;
kgdb_trgt_ops.to_remove_breakpoint = kgdb_trgt_ignore_breakpoints;
Don't close the kernel bfd object during startup. Instead, leave it open and build a section table from the kernel file so that 'info files' output for kgdb now matches the usage of gdb on a regular file with the exception that we don't list sections for memory in the crash dump.
2008-01-29 23:37:59 +00:00
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
add_target(&kgdb_trgt_ops);
Restore the 'proc' and 'tid' commands which allow one to switch to the first thread in a process or to a specific thread via PIDs and TIDs, respectively. Submitted by: kan Approved by: marcel
2006-10-16 20:06:32 +00:00
add_com ("proc", class_obscure, kgdb_set_proc_cmd,
"Set current process context");
add_com ("tid", class_obscure, kgdb_set_tid_cmd,
"Set current thread context");
Add the beginnings of kernel debugging support. the kgdb(1) tool is basicly a shell on top of libgdb that knows about kernel threads, kernel modules and kvm(3). As the word "beginnings" implies, not all of the features have been implemented yet. The tool is useful and I'd like feedback on the taken route. The simplest way to debug a kernel core file is: kgdb -n 0 This opens /var/crash/vmcore.0 with the corresponding kernel in the object directory (kernel.debug is used if it exists). Typical things that need to be added are: o Auto loading of kernel modules, o Handling of trapframes so that backtraces can be taken across them, o Some fancy commands to extract useful information out of a core file, o Various (probably many) other things.
2004-07-25 05:29:15 +00:00
}
Reference in New Issue Copy Permalink