2005-01-06 01:34:41 +00:00
|
|
|
/*-
|
1993-06-12 14:58:17 +00:00
|
|
|
* Mach Operating System
|
|
|
|
* Copyright (c) 1991,1990 Carnegie Mellon University
|
|
|
|
* All Rights Reserved.
|
1995-05-30 08:16:23 +00:00
|
|
|
*
|
1993-06-12 14:58:17 +00:00
|
|
|
* Permission to use, copy, modify and distribute this software and its
|
|
|
|
* documentation is hereby granted, provided that both the copyright
|
|
|
|
* notice and this permission notice appear in all copies of the
|
|
|
|
* software, derivative works or modified versions, and any portions
|
|
|
|
* thereof, and that both notices appear in supporting documentation.
|
1995-05-30 08:16:23 +00:00
|
|
|
*
|
|
|
|
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
|
1993-06-12 14:58:17 +00:00
|
|
|
* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
|
|
|
|
* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
|
1995-05-30 08:16:23 +00:00
|
|
|
*
|
1993-06-12 14:58:17 +00:00
|
|
|
* Carnegie Mellon requests users of this software to return to
|
1995-05-30 08:16:23 +00:00
|
|
|
*
|
1993-06-12 14:58:17 +00:00
|
|
|
* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
|
|
|
|
* School of Computer Science
|
|
|
|
* Carnegie Mellon University
|
|
|
|
* Pittsburgh PA 15213-3890
|
1995-05-30 08:16:23 +00:00
|
|
|
*
|
1993-06-12 14:58:17 +00:00
|
|
|
* any improvements or extensions that they make and grant Carnegie the
|
|
|
|
* rights to redistribute these changes.
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* Author: David B. Golub, Carnegie Mellon University
|
|
|
|
* Date: 7/90
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* Command dispatcher.
|
|
|
|
*/
|
2003-06-10 22:09:23 +00:00
|
|
|
|
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
1994-08-13 03:50:34 +00:00
|
|
|
#include <sys/param.h>
|
1999-01-14 06:22:10 +00:00
|
|
|
#include <sys/linker_set.h>
|
2001-11-27 19:56:28 +00:00
|
|
|
#include <sys/lock.h>
|
2004-07-10 23:47:20 +00:00
|
|
|
#include <sys/kdb.h>
|
2001-11-27 19:56:28 +00:00
|
|
|
#include <sys/mutex.h>
|
|
|
|
#include <sys/proc.h>
|
1996-08-27 19:46:28 +00:00
|
|
|
#include <sys/reboot.h>
|
2001-11-27 19:56:28 +00:00
|
|
|
#include <sys/signalvar.h>
|
1994-08-13 03:50:34 +00:00
|
|
|
#include <sys/systm.h>
|
1999-08-09 10:35:05 +00:00
|
|
|
#include <sys/cons.h>
|
2004-02-29 09:55:32 +00:00
|
|
|
#include <sys/watchdog.h>
|
1999-05-09 10:51:13 +00:00
|
|
|
|
1995-12-10 19:08:32 +00:00
|
|
|
#include <ddb/ddb.h>
|
1995-11-24 14:13:42 +00:00
|
|
|
#include <ddb/db_command.h>
|
1993-06-12 14:58:17 +00:00
|
|
|
#include <ddb/db_lex.h>
|
|
|
|
#include <ddb/db_output.h>
|
|
|
|
|
2003-08-16 16:57:57 +00:00
|
|
|
#include <machine/cpu.h>
|
2001-07-08 04:56:07 +00:00
|
|
|
#include <machine/setjmp.h>
|
1993-06-12 14:58:17 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Exported global variables
|
|
|
|
*/
|
|
|
|
boolean_t db_cmd_loop_done;
|
|
|
|
db_addr_t db_dot;
|
|
|
|
db_addr_t db_last_addr;
|
|
|
|
db_addr_t db_prev;
|
|
|
|
db_addr_t db_next;
|
2001-06-13 10:58:39 +00:00
|
|
|
|
|
|
|
SET_DECLARE(db_cmd_set, struct command);
|
|
|
|
SET_DECLARE(db_show_cmd_set, struct command);
|
1993-06-12 14:58:17 +00:00
|
|
|
|
1995-11-29 10:25:50 +00:00
|
|
|
static db_cmdfcn_t db_fncall;
|
2004-07-12 01:38:07 +00:00
|
|
|
static db_cmdfcn_t db_gdb;
|
2006-10-10 07:26:54 +00:00
|
|
|
static db_cmdfcn_t db_halt;
|
2001-11-27 19:56:28 +00:00
|
|
|
static db_cmdfcn_t db_kill;
|
2001-11-03 04:55:48 +00:00
|
|
|
static db_cmdfcn_t db_reset;
|
2004-07-21 05:07:09 +00:00
|
|
|
static db_cmdfcn_t db_stack_trace;
|
2005-10-02 11:41:12 +00:00
|
|
|
static db_cmdfcn_t db_stack_trace_all;
|
2004-02-29 09:55:32 +00:00
|
|
|
static db_cmdfcn_t db_watchdog;
|
1996-08-27 19:46:28 +00:00
|
|
|
|
2005-08-10 07:08:14 +00:00
|
|
|
/*
|
|
|
|
* 'show' commands
|
|
|
|
*/
|
|
|
|
|
|
|
|
static struct command db_show_all_cmds[] = {
|
|
|
|
{ "procs", db_ps, 0, 0 },
|
|
|
|
{ (char *)0 }
|
|
|
|
};
|
|
|
|
|
2006-03-07 22:17:06 +00:00
|
|
|
static struct command_table db_show_all_table = {
|
|
|
|
db_show_all_cmds
|
|
|
|
};
|
|
|
|
|
2005-08-10 07:08:14 +00:00
|
|
|
static struct command db_show_cmds[] = {
|
2006-03-07 22:17:06 +00:00
|
|
|
{ "all", 0, 0, &db_show_all_table },
|
2005-08-10 07:08:14 +00:00
|
|
|
{ "registers", db_show_regs, 0, 0 },
|
|
|
|
{ "breaks", db_listbreak_cmd, 0, 0 },
|
|
|
|
{ "threads", db_show_threads, 0, 0 },
|
|
|
|
{ (char *)0, }
|
|
|
|
};
|
|
|
|
|
2006-03-07 22:17:06 +00:00
|
|
|
static struct command_table db_show_table = {
|
|
|
|
db_show_cmds,
|
|
|
|
SET_BEGIN(db_show_cmd_set),
|
|
|
|
SET_LIMIT(db_show_cmd_set)
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct command db_commands[] = {
|
2005-08-10 07:08:14 +00:00
|
|
|
{ "print", db_print_cmd, 0, 0 },
|
|
|
|
{ "p", db_print_cmd, 0, 0 },
|
|
|
|
{ "examine", db_examine_cmd, CS_SET_DOT, 0 },
|
|
|
|
{ "x", db_examine_cmd, CS_SET_DOT, 0 },
|
|
|
|
{ "search", db_search_cmd, CS_OWN|CS_SET_DOT, 0 },
|
|
|
|
{ "set", db_set_cmd, CS_OWN, 0 },
|
|
|
|
{ "write", db_write_cmd, CS_MORE|CS_SET_DOT, 0 },
|
|
|
|
{ "w", db_write_cmd, CS_MORE|CS_SET_DOT, 0 },
|
|
|
|
{ "delete", db_delete_cmd, 0, 0 },
|
|
|
|
{ "d", db_delete_cmd, 0, 0 },
|
|
|
|
{ "break", db_breakpoint_cmd, 0, 0 },
|
2006-10-08 18:37:00 +00:00
|
|
|
{ "b", db_breakpoint_cmd, 0, 0 },
|
2005-08-10 07:08:14 +00:00
|
|
|
{ "dwatch", db_deletewatch_cmd, 0, 0 },
|
|
|
|
{ "watch", db_watchpoint_cmd, CS_MORE,0 },
|
|
|
|
{ "dhwatch", db_deletehwatch_cmd, 0, 0 },
|
|
|
|
{ "hwatch", db_hwatchpoint_cmd, 0, 0 },
|
|
|
|
{ "step", db_single_step_cmd, 0, 0 },
|
|
|
|
{ "s", db_single_step_cmd, 0, 0 },
|
|
|
|
{ "continue", db_continue_cmd, 0, 0 },
|
|
|
|
{ "c", db_continue_cmd, 0, 0 },
|
|
|
|
{ "until", db_trace_until_call_cmd,0, 0 },
|
|
|
|
{ "next", db_trace_until_matching_cmd,0, 0 },
|
|
|
|
{ "match", db_trace_until_matching_cmd,0, 0 },
|
|
|
|
{ "trace", db_stack_trace, CS_OWN, 0 },
|
2006-10-08 18:37:00 +00:00
|
|
|
{ "t", db_stack_trace, CS_OWN, 0 },
|
2005-10-24 15:21:36 +00:00
|
|
|
{ "alltrace", db_stack_trace_all, 0, 0 },
|
2005-08-10 07:08:14 +00:00
|
|
|
{ "where", db_stack_trace, CS_OWN, 0 },
|
2005-10-24 15:21:36 +00:00
|
|
|
{ "bt", db_stack_trace, CS_OWN, 0 },
|
2005-08-10 07:08:14 +00:00
|
|
|
{ "call", db_fncall, CS_OWN, 0 },
|
2006-03-07 22:17:06 +00:00
|
|
|
{ "show", 0, 0, &db_show_table },
|
2005-08-10 07:08:14 +00:00
|
|
|
{ "ps", db_ps, 0, 0 },
|
|
|
|
{ "gdb", db_gdb, 0, 0 },
|
2006-10-10 07:26:54 +00:00
|
|
|
{ "halt", db_halt, 0, 0 },
|
|
|
|
{ "reboot", db_reset, 0, 0 },
|
2005-08-10 07:08:14 +00:00
|
|
|
{ "reset", db_reset, 0, 0 },
|
|
|
|
{ "kill", db_kill, CS_OWN, 0 },
|
|
|
|
{ "watchdog", db_watchdog, 0, 0 },
|
|
|
|
{ "thread", db_set_thread, CS_OWN, 0 },
|
Add a simple scripting facility to DDB(4), allowing the user to
define a set of named scripts. Each script consists of a list of DDB
commands separated by ";"s that will be executed verbatim. No higher
level language constructs, such as branching, are provided for:
scripts are executed by sequentially injecting commands into the DDB
input buffer.
Four new commands are present in DDB: "run" to run a specific script,
"script" to define or print a script, "scripts" to list currently
defined scripts, and "unscript" to delete a script, modeled on shell
alias commands. Scripts may also be manipulated using sysctls in the
debug.ddb.scripting MIB space, although users will prefer to use the
soon-to-be-added ddb(8) tool for usability reasons.
Scripts with certain names are automatically executed on various DDB
events, such as entering the debugger via a panic, a witness error,
watchdog, breakpoint, sysctl, serial break, etc, allowing customized
handling.
MFC after: 3 months
2007-12-26 09:33:19 +00:00
|
|
|
{ "run", db_run_cmd, CS_OWN, 0 },
|
|
|
|
{ "script", db_script_cmd, CS_OWN, 0 },
|
|
|
|
{ "scripts", db_scripts_cmd, 0, 0 },
|
|
|
|
{ "unscript", db_unscript_cmd, CS_OWN, 0 },
|
Add a new DDB(4) facility, output capture. Input and output from DDB may be
captured to a memory buffer for later inspection using sysctl(8), or in the
future, to a textdump.
A new DDB command, "capture", is added, which accepts arguments "on", "off",
"reset", and "status".
A new DDB sysctl tree, debug.ddb.capture, is added, which can be used to
resize the capture buffer and extract buffer contents.
MFC after: 3 months
2007-12-25 23:06:51 +00:00
|
|
|
{ "capture", db_capture_cmd, CS_OWN, 0 },
|
Add textdump(4) facility, which provides an alternative form of kernel
dump using mechanically generated/extracted debugging output rather than
a simple memory dump. Current sources of debugging output are:
- DDB output capture buffer, if there is captured output to save
- Kernel message buffer
- Kernel configuration, if included in kernel
- Kernel version string
- Panic message
Textdumps are stored in swap/dump partitions as with regular dumps, but
are laid out as ustar files in order to allow multiple parts to be stored
as a stream of sequentially written blocks. Blocks are written out in
reverse order, as the size of a textdump isn't known a priori. As with
regular dumps, they will be extracted using savecore(8).
One new DDB(4) command is added, "textdump", which accepts "set",
"unset", and "status" arguments. By default, normal kernel dumps are
generated unless "textdump set" is run in order to schedule a textdump.
It can be canceled using "textdump unset" to restore generation of a
normal kernel dump.
Several sysctls exist to configure aspects of textdumps;
debug.ddb.textdump.pending can be set to check whether a textdump is
pending, or set/unset in order to control whether the next kernel dump
will be a textdump from userspace.
While textdumps don't have to be generated as a result of a DDB script
run automatically as part of a kernel panic, this is a particular useful
way to use them, as instead of generating a complete memory dump, a
simple transcript of an automated DDB session can be captured using the
DDB output capture and textdump facilities. This can be used to
generate quite brief kernel bug reports rich in debugging information
but not dependent on kernel symbol tables or precisely synchronized
source code. Most textdumps I generate are less than 100k including
the full message buffer. Using textdumps with an interactive debugging
session is also useful, with capture being enabled/disabled in order to
record some but not all of the DDB session.
MFC after: 3 months
2007-12-26 11:32:33 +00:00
|
|
|
{ "textdump", db_textdump_cmd, CS_OWN, 0 },
|
2005-08-10 07:08:14 +00:00
|
|
|
{ (char *)0, }
|
|
|
|
};
|
|
|
|
|
2006-03-07 22:17:06 +00:00
|
|
|
static struct command_table db_command_table = {
|
|
|
|
db_commands,
|
|
|
|
SET_BEGIN(db_cmd_set),
|
|
|
|
SET_LIMIT(db_cmd_set)
|
|
|
|
};
|
|
|
|
|
2005-08-10 07:08:14 +00:00
|
|
|
static struct command *db_last_command = 0;
|
1996-09-14 09:13:15 +00:00
|
|
|
|
1993-06-12 14:58:17 +00:00
|
|
|
/*
|
|
|
|
* if 'ed' style: 'dot' is set at start of last item printed,
|
|
|
|
* and '+' points to next line.
|
|
|
|
* Otherwise: 'dot' points to next item, '..' points to last.
|
|
|
|
*/
|
1995-11-29 10:25:50 +00:00
|
|
|
static boolean_t db_ed_style = TRUE;
|
1993-06-12 14:58:17 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Utility routine - discard tokens through end-of-line.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
db_skip_to_eol()
|
|
|
|
{
|
|
|
|
int t;
|
|
|
|
do {
|
|
|
|
t = db_read_token();
|
|
|
|
} while (t != tEOL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Results of command search.
|
|
|
|
*/
|
|
|
|
#define CMD_UNIQUE 0
|
|
|
|
#define CMD_FOUND 1
|
|
|
|
#define CMD_NONE 2
|
|
|
|
#define CMD_AMBIGUOUS 3
|
|
|
|
#define CMD_HELP 4
|
|
|
|
|
2006-03-07 22:17:06 +00:00
|
|
|
static void db_cmd_match(char *name, struct command *cmd,
|
|
|
|
struct command **cmdp, int *resultp);
|
|
|
|
static void db_cmd_list(struct command_table *table);
|
|
|
|
static int db_cmd_search(char *name, struct command_table *table,
|
|
|
|
struct command **cmdp);
|
2002-03-20 05:14:42 +00:00
|
|
|
static void db_command(struct command **last_cmdp,
|
Add a simple scripting facility to DDB(4), allowing the user to
define a set of named scripts. Each script consists of a list of DDB
commands separated by ";"s that will be executed verbatim. No higher
level language constructs, such as branching, are provided for:
scripts are executed by sequentially injecting commands into the DDB
input buffer.
Four new commands are present in DDB: "run" to run a specific script,
"script" to define or print a script, "scripts" to list currently
defined scripts, and "unscript" to delete a script, modeled on shell
alias commands. Scripts may also be manipulated using sysctls in the
debug.ddb.scripting MIB space, although users will prefer to use the
soon-to-be-added ddb(8) tool for usability reasons.
Scripts with certain names are automatically executed on various DDB
events, such as entering the debugger via a panic, a witness error,
watchdog, breakpoint, sysctl, serial break, etc, allowing customized
handling.
MFC after: 3 months
2007-12-26 09:33:19 +00:00
|
|
|
struct command_table *cmd_table, int dopager);
|
1995-11-24 14:13:42 +00:00
|
|
|
|
1993-06-12 14:58:17 +00:00
|
|
|
/*
|
2006-03-07 22:17:06 +00:00
|
|
|
* Helper function to match a single command.
|
1993-06-12 14:58:17 +00:00
|
|
|
*/
|
2006-03-07 22:17:06 +00:00
|
|
|
static void
|
|
|
|
db_cmd_match(name, cmd, cmdp, resultp)
|
1993-06-12 14:58:17 +00:00
|
|
|
char * name;
|
2006-03-07 22:17:06 +00:00
|
|
|
struct command *cmd;
|
1993-06-12 14:58:17 +00:00
|
|
|
struct command **cmdp; /* out */
|
2006-03-07 22:17:06 +00:00
|
|
|
int * resultp;
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
2006-03-07 22:17:06 +00:00
|
|
|
char *lp, *rp;
|
|
|
|
int c;
|
1993-06-12 14:58:17 +00:00
|
|
|
|
2006-03-07 22:17:06 +00:00
|
|
|
lp = name;
|
|
|
|
rp = cmd->name;
|
|
|
|
while ((c = *lp) == *rp) {
|
1993-06-12 14:58:17 +00:00
|
|
|
if (c == 0) {
|
2006-03-07 22:17:06 +00:00
|
|
|
/* complete match */
|
|
|
|
*cmdp = cmd;
|
|
|
|
*resultp = CMD_UNIQUE;
|
|
|
|
return;
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
lp++;
|
|
|
|
rp++;
|
2006-03-07 22:17:06 +00:00
|
|
|
}
|
|
|
|
if (c == 0) {
|
1993-06-12 14:58:17 +00:00
|
|
|
/* end of name, not end of command -
|
|
|
|
partial match */
|
2006-03-07 22:17:06 +00:00
|
|
|
if (*resultp == CMD_FOUND) {
|
|
|
|
*resultp = CMD_AMBIGUOUS;
|
|
|
|
/* but keep looking for a full match -
|
|
|
|
this lets us match single letters */
|
|
|
|
} else {
|
|
|
|
*cmdp = cmd;
|
|
|
|
*resultp = CMD_FOUND;
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
}
|
2006-03-07 22:17:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Search for command prefix.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
db_cmd_search(name, table, cmdp)
|
|
|
|
char * name;
|
|
|
|
struct command_table *table;
|
|
|
|
struct command **cmdp; /* out */
|
|
|
|
{
|
|
|
|
struct command *cmd;
|
|
|
|
struct command **aux_cmdp;
|
|
|
|
int result = CMD_NONE;
|
|
|
|
|
|
|
|
for (cmd = table->table; cmd->name != 0; cmd++) {
|
|
|
|
db_cmd_match(name, cmd, cmdp, &result);
|
|
|
|
if (result == CMD_UNIQUE)
|
1996-09-14 09:13:15 +00:00
|
|
|
return (CMD_UNIQUE);
|
2006-03-07 22:17:06 +00:00
|
|
|
}
|
|
|
|
if (table->aux_tablep != NULL)
|
|
|
|
for (aux_cmdp = table->aux_tablep;
|
|
|
|
aux_cmdp < table->aux_tablep_end;
|
|
|
|
aux_cmdp++) {
|
|
|
|
db_cmd_match(name, *aux_cmdp, cmdp, &result);
|
|
|
|
if (result == CMD_UNIQUE)
|
|
|
|
return (CMD_UNIQUE);
|
1996-09-14 09:13:15 +00:00
|
|
|
}
|
1993-06-12 14:58:17 +00:00
|
|
|
if (result == CMD_NONE) {
|
2006-03-07 22:17:06 +00:00
|
|
|
/* check for 'help' */
|
1993-06-12 14:58:17 +00:00
|
|
|
if (name[0] == 'h' && name[1] == 'e'
|
|
|
|
&& name[2] == 'l' && name[3] == 'p')
|
|
|
|
result = CMD_HELP;
|
|
|
|
}
|
|
|
|
return (result);
|
|
|
|
}
|
|
|
|
|
1995-11-29 10:25:50 +00:00
|
|
|
static void
|
2006-03-07 22:17:06 +00:00
|
|
|
db_cmd_list(table)
|
|
|
|
struct command_table *table;
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
|
|
|
register struct command *cmd;
|
1996-09-14 09:13:15 +00:00
|
|
|
register struct command **aux_cmdp;
|
1993-06-12 14:58:17 +00:00
|
|
|
|
2006-03-07 22:17:06 +00:00
|
|
|
for (cmd = table->table; cmd->name != 0; cmd++) {
|
1993-06-12 14:58:17 +00:00
|
|
|
db_printf("%-12s", cmd->name);
|
2006-10-08 18:15:08 +00:00
|
|
|
db_end_line(12);
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
2006-03-07 22:17:06 +00:00
|
|
|
if (table->aux_tablep == NULL)
|
1996-09-14 09:13:15 +00:00
|
|
|
return;
|
2006-03-07 22:17:06 +00:00
|
|
|
for (aux_cmdp = table->aux_tablep; aux_cmdp < table->aux_tablep_end;
|
|
|
|
aux_cmdp++) {
|
1996-09-14 09:13:15 +00:00
|
|
|
db_printf("%-12s", (*aux_cmdp)->name);
|
2006-10-08 18:15:08 +00:00
|
|
|
db_end_line(12);
|
1996-09-14 09:13:15 +00:00
|
|
|
}
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
|
1995-11-29 10:25:50 +00:00
|
|
|
static void
|
Add a simple scripting facility to DDB(4), allowing the user to
define a set of named scripts. Each script consists of a list of DDB
commands separated by ";"s that will be executed verbatim. No higher
level language constructs, such as branching, are provided for:
scripts are executed by sequentially injecting commands into the DDB
input buffer.
Four new commands are present in DDB: "run" to run a specific script,
"script" to define or print a script, "scripts" to list currently
defined scripts, and "unscript" to delete a script, modeled on shell
alias commands. Scripts may also be manipulated using sysctls in the
debug.ddb.scripting MIB space, although users will prefer to use the
soon-to-be-added ddb(8) tool for usability reasons.
Scripts with certain names are automatically executed on various DDB
events, such as entering the debugger via a panic, a witness error,
watchdog, breakpoint, sysctl, serial break, etc, allowing customized
handling.
MFC after: 3 months
2007-12-26 09:33:19 +00:00
|
|
|
db_command(last_cmdp, cmd_table, dopager)
|
1993-06-12 14:58:17 +00:00
|
|
|
struct command **last_cmdp; /* IN_OUT */
|
2006-03-07 22:17:06 +00:00
|
|
|
struct command_table *cmd_table;
|
Add a simple scripting facility to DDB(4), allowing the user to
define a set of named scripts. Each script consists of a list of DDB
commands separated by ";"s that will be executed verbatim. No higher
level language constructs, such as branching, are provided for:
scripts are executed by sequentially injecting commands into the DDB
input buffer.
Four new commands are present in DDB: "run" to run a specific script,
"script" to define or print a script, "scripts" to list currently
defined scripts, and "unscript" to delete a script, modeled on shell
alias commands. Scripts may also be manipulated using sysctls in the
debug.ddb.scripting MIB space, although users will prefer to use the
soon-to-be-added ddb(8) tool for usability reasons.
Scripts with certain names are automatically executed on various DDB
events, such as entering the debugger via a panic, a witness error,
watchdog, breakpoint, sysctl, serial break, etc, allowing customized
handling.
MFC after: 3 months
2007-12-26 09:33:19 +00:00
|
|
|
int dopager;
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
|
|
|
struct command *cmd;
|
|
|
|
int t;
|
|
|
|
char modif[TOK_STRING_SIZE];
|
|
|
|
db_expr_t addr, count;
|
1993-11-25 01:38:01 +00:00
|
|
|
boolean_t have_addr = FALSE;
|
1993-06-12 14:58:17 +00:00
|
|
|
int result;
|
|
|
|
|
|
|
|
t = db_read_token();
|
|
|
|
if (t == tEOL) {
|
|
|
|
/* empty line repeats last command, at 'next' */
|
|
|
|
cmd = *last_cmdp;
|
|
|
|
addr = (db_expr_t)db_next;
|
|
|
|
have_addr = FALSE;
|
|
|
|
count = 1;
|
|
|
|
modif[0] = '\0';
|
|
|
|
}
|
|
|
|
else if (t == tEXCL) {
|
1995-08-27 02:39:39 +00:00
|
|
|
db_fncall((db_expr_t)0, (boolean_t)0, (db_expr_t)0, (char *)0);
|
1993-06-12 14:58:17 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
else if (t != tIDENT) {
|
|
|
|
db_printf("?\n");
|
|
|
|
db_flush_lex();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/*
|
|
|
|
* Search for command
|
|
|
|
*/
|
|
|
|
while (cmd_table) {
|
|
|
|
result = db_cmd_search(db_tok_string,
|
|
|
|
cmd_table,
|
|
|
|
&cmd);
|
|
|
|
switch (result) {
|
|
|
|
case CMD_NONE:
|
|
|
|
db_printf("No such command\n");
|
|
|
|
db_flush_lex();
|
|
|
|
return;
|
|
|
|
case CMD_AMBIGUOUS:
|
|
|
|
db_printf("Ambiguous\n");
|
|
|
|
db_flush_lex();
|
|
|
|
return;
|
|
|
|
case CMD_HELP:
|
2006-03-07 22:17:06 +00:00
|
|
|
db_cmd_list(cmd_table);
|
1993-06-12 14:58:17 +00:00
|
|
|
db_flush_lex();
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2006-03-07 22:17:06 +00:00
|
|
|
if ((cmd_table = cmd->more) != NULL) {
|
1993-06-12 14:58:17 +00:00
|
|
|
t = db_read_token();
|
|
|
|
if (t != tIDENT) {
|
2006-03-07 22:17:06 +00:00
|
|
|
db_cmd_list(cmd_table);
|
1993-06-12 14:58:17 +00:00
|
|
|
db_flush_lex();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((cmd->flag & CS_OWN) == 0) {
|
|
|
|
/*
|
|
|
|
* Standard syntax:
|
|
|
|
* command [/modifier] [addr] [,count]
|
|
|
|
*/
|
|
|
|
t = db_read_token();
|
|
|
|
if (t == tSLASH) {
|
|
|
|
t = db_read_token();
|
|
|
|
if (t != tIDENT) {
|
|
|
|
db_printf("Bad modifier\n");
|
|
|
|
db_flush_lex();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
db_strcpy(modif, db_tok_string);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
db_unread_token(t);
|
|
|
|
modif[0] = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
if (db_expression(&addr)) {
|
|
|
|
db_dot = (db_addr_t) addr;
|
|
|
|
db_last_addr = db_dot;
|
|
|
|
have_addr = TRUE;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
addr = (db_expr_t) db_dot;
|
|
|
|
have_addr = FALSE;
|
|
|
|
}
|
|
|
|
t = db_read_token();
|
|
|
|
if (t == tCOMMA) {
|
|
|
|
if (!db_expression(&count)) {
|
|
|
|
db_printf("Count missing\n");
|
|
|
|
db_flush_lex();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
db_unread_token(t);
|
|
|
|
count = -1;
|
|
|
|
}
|
|
|
|
if ((cmd->flag & CS_MORE) == 0) {
|
|
|
|
db_skip_to_eol();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*last_cmdp = cmd;
|
|
|
|
if (cmd != 0) {
|
|
|
|
/*
|
|
|
|
* Execute the command.
|
|
|
|
*/
|
Add a simple scripting facility to DDB(4), allowing the user to
define a set of named scripts. Each script consists of a list of DDB
commands separated by ";"s that will be executed verbatim. No higher
level language constructs, such as branching, are provided for:
scripts are executed by sequentially injecting commands into the DDB
input buffer.
Four new commands are present in DDB: "run" to run a specific script,
"script" to define or print a script, "scripts" to list currently
defined scripts, and "unscript" to delete a script, modeled on shell
alias commands. Scripts may also be manipulated using sysctls in the
debug.ddb.scripting MIB space, although users will prefer to use the
soon-to-be-added ddb(8) tool for usability reasons.
Scripts with certain names are automatically executed on various DDB
events, such as entering the debugger via a panic, a witness error,
watchdog, breakpoint, sysctl, serial break, etc, allowing customized
handling.
MFC after: 3 months
2007-12-26 09:33:19 +00:00
|
|
|
if (dopager)
|
|
|
|
db_enable_pager();
|
|
|
|
else
|
|
|
|
db_disable_pager();
|
1993-06-12 14:58:17 +00:00
|
|
|
(*cmd->fcn)(addr, have_addr, count, modif);
|
Add a simple scripting facility to DDB(4), allowing the user to
define a set of named scripts. Each script consists of a list of DDB
commands separated by ";"s that will be executed verbatim. No higher
level language constructs, such as branching, are provided for:
scripts are executed by sequentially injecting commands into the DDB
input buffer.
Four new commands are present in DDB: "run" to run a specific script,
"script" to define or print a script, "scripts" to list currently
defined scripts, and "unscript" to delete a script, modeled on shell
alias commands. Scripts may also be manipulated using sysctls in the
debug.ddb.scripting MIB space, although users will prefer to use the
soon-to-be-added ddb(8) tool for usability reasons.
Scripts with certain names are automatically executed on various DDB
events, such as entering the debugger via a panic, a witness error,
watchdog, breakpoint, sysctl, serial break, etc, allowing customized
handling.
MFC after: 3 months
2007-12-26 09:33:19 +00:00
|
|
|
if (dopager)
|
|
|
|
db_disable_pager();
|
1993-06-12 14:58:17 +00:00
|
|
|
|
|
|
|
if (cmd->flag & CS_SET_DOT) {
|
|
|
|
/*
|
|
|
|
* If command changes dot, set dot to
|
|
|
|
* previous address displayed (if 'ed' style).
|
|
|
|
*/
|
|
|
|
if (db_ed_style) {
|
|
|
|
db_dot = db_prev;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
db_dot = db_next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/*
|
|
|
|
* If command does not change dot,
|
|
|
|
* set 'next' location to be the same.
|
|
|
|
*/
|
|
|
|
db_next = db_dot;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1998-02-13 02:19:29 +00:00
|
|
|
/*
|
|
|
|
* At least one non-optional command must be implemented using
|
|
|
|
* DB_COMMAND() so that db_cmd_set gets created. Here is one.
|
|
|
|
*/
|
|
|
|
DB_COMMAND(panic, db_panic)
|
1995-02-05 21:09:04 +00:00
|
|
|
{
|
2006-07-19 18:26:53 +00:00
|
|
|
db_disable_pager();
|
1995-03-19 14:29:26 +00:00
|
|
|
panic("from debugger");
|
1995-02-05 21:09:04 +00:00
|
|
|
}
|
|
|
|
|
1993-06-12 14:58:17 +00:00
|
|
|
void
|
|
|
|
db_command_loop()
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Initialize 'prev' and 'next' to dot.
|
|
|
|
*/
|
|
|
|
db_prev = db_dot;
|
|
|
|
db_next = db_dot;
|
|
|
|
|
|
|
|
db_cmd_loop_done = 0;
|
|
|
|
while (!db_cmd_loop_done) {
|
|
|
|
if (db_print_position() != 0)
|
|
|
|
db_printf("\n");
|
|
|
|
|
|
|
|
db_printf("db> ");
|
|
|
|
(void) db_read_line();
|
|
|
|
|
Add a simple scripting facility to DDB(4), allowing the user to
define a set of named scripts. Each script consists of a list of DDB
commands separated by ";"s that will be executed verbatim. No higher
level language constructs, such as branching, are provided for:
scripts are executed by sequentially injecting commands into the DDB
input buffer.
Four new commands are present in DDB: "run" to run a specific script,
"script" to define or print a script, "scripts" to list currently
defined scripts, and "unscript" to delete a script, modeled on shell
alias commands. Scripts may also be manipulated using sysctls in the
debug.ddb.scripting MIB space, although users will prefer to use the
soon-to-be-added ddb(8) tool for usability reasons.
Scripts with certain names are automatically executed on various DDB
events, such as entering the debugger via a panic, a witness error,
watchdog, breakpoint, sysctl, serial break, etc, allowing customized
handling.
MFC after: 3 months
2007-12-26 09:33:19 +00:00
|
|
|
db_command(&db_last_command, &db_command_table, /* dopager */ 1);
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Add a simple scripting facility to DDB(4), allowing the user to
define a set of named scripts. Each script consists of a list of DDB
commands separated by ";"s that will be executed verbatim. No higher
level language constructs, such as branching, are provided for:
scripts are executed by sequentially injecting commands into the DDB
input buffer.
Four new commands are present in DDB: "run" to run a specific script,
"script" to define or print a script, "scripts" to list currently
defined scripts, and "unscript" to delete a script, modeled on shell
alias commands. Scripts may also be manipulated using sysctls in the
debug.ddb.scripting MIB space, although users will prefer to use the
soon-to-be-added ddb(8) tool for usability reasons.
Scripts with certain names are automatically executed on various DDB
events, such as entering the debugger via a panic, a witness error,
watchdog, breakpoint, sysctl, serial break, etc, allowing customized
handling.
MFC after: 3 months
2007-12-26 09:33:19 +00:00
|
|
|
/*
|
|
|
|
* Execute a command on behalf of a script. The caller is responsible for
|
|
|
|
* making sure that the command string is < DB_MAXLINE or it will be
|
|
|
|
* truncated.
|
|
|
|
*
|
|
|
|
* XXXRW: Runs by injecting faked input into DDB input stream; it would be
|
|
|
|
* nicer to use an alternative approach that didn't mess with the previous
|
|
|
|
* command buffer.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
db_command_script(const char *command)
|
|
|
|
{
|
|
|
|
db_prev = db_next = db_dot;
|
|
|
|
db_inject_line(command);
|
|
|
|
db_command(&db_last_command, &db_command_table, /* dopager */ 0);
|
|
|
|
}
|
|
|
|
|
1993-06-12 14:58:17 +00:00
|
|
|
void
|
|
|
|
db_error(s)
|
2002-09-21 17:29:36 +00:00
|
|
|
const char *s;
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
|
|
|
if (s)
|
2001-07-19 02:05:00 +00:00
|
|
|
db_printf("%s", s);
|
1993-06-12 14:58:17 +00:00
|
|
|
db_flush_lex();
|
2004-07-10 23:47:20 +00:00
|
|
|
kdb_reenter();
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Call random function:
|
|
|
|
* !expr(arg,arg,arg)
|
|
|
|
*/
|
2005-07-02 23:52:37 +00:00
|
|
|
|
|
|
|
/* The generic implementation supports a maximum of 10 arguments. */
|
|
|
|
typedef db_expr_t __db_f(db_expr_t, db_expr_t, db_expr_t, db_expr_t,
|
|
|
|
db_expr_t, db_expr_t, db_expr_t, db_expr_t, db_expr_t, db_expr_t);
|
|
|
|
|
|
|
|
static __inline int
|
|
|
|
db_fncall_generic(db_expr_t addr, db_expr_t *rv, int nargs, db_expr_t args[])
|
|
|
|
{
|
|
|
|
__db_f *f = (__db_f *)addr;
|
|
|
|
|
|
|
|
if (nargs > 10) {
|
|
|
|
db_printf("Too many arguments (max 10)\n");
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
*rv = (*f)(args[0], args[1], args[2], args[3], args[4], args[5],
|
|
|
|
args[6], args[7], args[8], args[9]);
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
1995-11-29 10:25:50 +00:00
|
|
|
static void
|
1995-08-27 02:39:39 +00:00
|
|
|
db_fncall(dummy1, dummy2, dummy3, dummy4)
|
|
|
|
db_expr_t dummy1;
|
|
|
|
boolean_t dummy2;
|
|
|
|
db_expr_t dummy3;
|
|
|
|
char * dummy4;
|
1993-06-12 14:58:17 +00:00
|
|
|
{
|
|
|
|
db_expr_t fn_addr;
|
2005-07-02 23:52:37 +00:00
|
|
|
db_expr_t args[DB_MAXARGS];
|
1993-06-12 14:58:17 +00:00
|
|
|
int nargs = 0;
|
|
|
|
db_expr_t retval;
|
|
|
|
int t;
|
|
|
|
|
|
|
|
if (!db_expression(&fn_addr)) {
|
|
|
|
db_printf("Bad function\n");
|
|
|
|
db_flush_lex();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
t = db_read_token();
|
|
|
|
if (t == tLPAREN) {
|
|
|
|
if (db_expression(&args[0])) {
|
|
|
|
nargs++;
|
|
|
|
while ((t = db_read_token()) == tCOMMA) {
|
2005-07-02 23:52:37 +00:00
|
|
|
if (nargs == DB_MAXARGS) {
|
|
|
|
db_printf("Too many arguments (max %d)\n", DB_MAXARGS);
|
1993-06-12 14:58:17 +00:00
|
|
|
db_flush_lex();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!db_expression(&args[nargs])) {
|
|
|
|
db_printf("Argument missing\n");
|
|
|
|
db_flush_lex();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
nargs++;
|
|
|
|
}
|
|
|
|
db_unread_token(t);
|
|
|
|
}
|
|
|
|
if (db_read_token() != tRPAREN) {
|
|
|
|
db_printf("?\n");
|
|
|
|
db_flush_lex();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
db_skip_to_eol();
|
2006-07-19 18:26:53 +00:00
|
|
|
db_disable_pager();
|
1993-06-12 14:58:17 +00:00
|
|
|
|
2005-07-02 23:52:37 +00:00
|
|
|
if (DB_CALL(fn_addr, &retval, nargs, args))
|
|
|
|
db_printf("= %#lr\n", (long)retval);
|
1993-06-12 14:58:17 +00:00
|
|
|
}
|
1996-08-27 19:46:28 +00:00
|
|
|
|
2006-10-10 07:26:54 +00:00
|
|
|
static void
|
|
|
|
db_halt(db_expr_t dummy, boolean_t dummy2, db_expr_t dummy3, char *dummy4)
|
|
|
|
{
|
|
|
|
|
|
|
|
cpu_halt();
|
|
|
|
}
|
|
|
|
|
2001-11-27 19:56:28 +00:00
|
|
|
static void
|
|
|
|
db_kill(dummy1, dummy2, dummy3, dummy4)
|
|
|
|
db_expr_t dummy1;
|
|
|
|
boolean_t dummy2;
|
|
|
|
db_expr_t dummy3;
|
|
|
|
char * dummy4;
|
|
|
|
{
|
|
|
|
db_expr_t old_radix, pid, sig;
|
|
|
|
struct proc *p;
|
|
|
|
|
|
|
|
#define DB_ERROR(f) do { db_printf f; db_flush_lex(); goto out; } while (0)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* PIDs and signal numbers are typically represented in base
|
|
|
|
* 10, so make that the default here. It can, of course, be
|
|
|
|
* overridden by specifying a prefix.
|
|
|
|
*/
|
|
|
|
old_radix = db_radix;
|
|
|
|
db_radix = 10;
|
|
|
|
/* Retrieve arguments. */
|
|
|
|
if (!db_expression(&sig))
|
|
|
|
DB_ERROR(("Missing signal number\n"));
|
|
|
|
if (!db_expression(&pid))
|
|
|
|
DB_ERROR(("Missing process ID\n"));
|
|
|
|
db_skip_to_eol();
|
|
|
|
if (sig < 0 || sig > _SIG_MAXSIG)
|
|
|
|
DB_ERROR(("Signal number out of range\n"));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the process in question. allproc_lock is not needed
|
|
|
|
* since we're in DDB.
|
|
|
|
*/
|
|
|
|
/* sx_slock(&allproc_lock); */
|
2007-01-17 15:05:52 +00:00
|
|
|
FOREACH_PROC_IN_SYSTEM(p)
|
2001-11-27 19:56:28 +00:00
|
|
|
if (p->p_pid == pid)
|
|
|
|
break;
|
|
|
|
/* sx_sunlock(&allproc_lock); */
|
|
|
|
if (p == NULL)
|
2002-01-17 02:14:44 +00:00
|
|
|
DB_ERROR(("Can't find process with pid %ld\n", (long) pid));
|
2001-11-27 19:56:28 +00:00
|
|
|
|
|
|
|
/* If it's already locked, bail; otherwise, do the deed. */
|
|
|
|
if (PROC_TRYLOCK(p) == 0)
|
2002-01-17 02:14:44 +00:00
|
|
|
DB_ERROR(("Can't lock process with pid %ld\n", (long) pid));
|
2001-11-27 19:56:28 +00:00
|
|
|
else {
|
|
|
|
psignal(p, sig);
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
db_radix = old_radix;
|
|
|
|
#undef DB_ERROR
|
|
|
|
}
|
|
|
|
|
2001-11-03 04:55:48 +00:00
|
|
|
static void
|
|
|
|
db_reset(dummy1, dummy2, dummy3, dummy4)
|
|
|
|
db_expr_t dummy1;
|
|
|
|
boolean_t dummy2;
|
|
|
|
db_expr_t dummy3;
|
|
|
|
char * dummy4;
|
|
|
|
{
|
|
|
|
|
|
|
|
cpu_reset();
|
|
|
|
}
|
2004-02-29 09:55:32 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
db_watchdog(dummy1, dummy2, dummy3, dummy4)
|
|
|
|
db_expr_t dummy1;
|
|
|
|
boolean_t dummy2;
|
|
|
|
db_expr_t dummy3;
|
|
|
|
char * dummy4;
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX: It might make sense to be able to set the watchdog to a
|
|
|
|
* XXX: timeout here so that failure or hang as a result of subsequent
|
|
|
|
* XXX: ddb commands could be recovered by a reset.
|
|
|
|
*/
|
|
|
|
|
|
|
|
EVENTHANDLER_INVOKE(watchdog_list, 0, &i);
|
|
|
|
}
|
2004-07-12 01:38:07 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
db_gdb(db_expr_t dummy1, boolean_t dummy2, db_expr_t dummy3, char *dummy4)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (kdb_dbbe_select("gdb") != 0)
|
|
|
|
db_printf("The remote GDB backend could not be selected.\n");
|
|
|
|
else
|
|
|
|
db_printf("Step to enter the remote GDB backend.\n");
|
|
|
|
}
|
2004-07-21 05:07:09 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
db_stack_trace(db_expr_t tid, boolean_t hastid, db_expr_t count, char *modif)
|
|
|
|
{
|
|
|
|
struct thread *td;
|
|
|
|
db_expr_t radix;
|
2004-11-23 23:11:47 +00:00
|
|
|
pid_t pid;
|
2004-07-21 05:07:09 +00:00
|
|
|
int t;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We parse our own arguments. We don't like the default radix.
|
|
|
|
*/
|
|
|
|
radix = db_radix;
|
|
|
|
db_radix = 10;
|
|
|
|
hastid = db_expression(&tid);
|
|
|
|
t = db_read_token();
|
|
|
|
if (t == tCOMMA) {
|
|
|
|
if (!db_expression(&count)) {
|
|
|
|
db_printf("Count missing\n");
|
|
|
|
db_flush_lex();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
db_unread_token(t);
|
|
|
|
count = -1;
|
|
|
|
}
|
|
|
|
db_skip_to_eol();
|
|
|
|
db_radix = radix;
|
|
|
|
|
|
|
|
if (hastid) {
|
|
|
|
td = kdb_thr_lookup((lwpid_t)tid);
|
|
|
|
if (td == NULL)
|
|
|
|
td = kdb_thr_from_pid((pid_t)tid);
|
|
|
|
if (td == NULL) {
|
|
|
|
db_printf("Thread %d not found\n", (int)tid);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
td = kdb_thread;
|
2004-11-23 23:11:47 +00:00
|
|
|
if (td->td_proc != NULL)
|
|
|
|
pid = td->td_proc->p_pid;
|
|
|
|
else
|
|
|
|
pid = -1;
|
|
|
|
db_printf("Tracing pid %d tid %ld td %p\n", pid, (long)td->td_tid, td);
|
2004-07-21 05:07:09 +00:00
|
|
|
db_trace_thread(td, count);
|
|
|
|
}
|
2005-10-02 11:41:12 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
db_stack_trace_all(db_expr_t dummy, boolean_t dummy2, db_expr_t dummy3,
|
|
|
|
char *dummy4)
|
|
|
|
{
|
|
|
|
struct proc *p;
|
|
|
|
struct thread *td;
|
2006-11-02 11:47:38 +00:00
|
|
|
jmp_buf jb;
|
|
|
|
void *prev_jb;
|
2005-10-02 11:41:12 +00:00
|
|
|
|
2007-01-17 15:05:52 +00:00
|
|
|
FOREACH_PROC_IN_SYSTEM(p) {
|
2006-11-02 11:47:38 +00:00
|
|
|
prev_jb = kdb_jmpbuf(jb);
|
|
|
|
if (setjmp(jb) == 0) {
|
|
|
|
FOREACH_THREAD_IN_PROC(p, td) {
|
|
|
|
db_printf("\nTracing command %s pid %d tid %ld td %p\n",
|
|
|
|
p->p_comm, p->p_pid, (long)td->td_tid, td);
|
|
|
|
db_trace_thread(td, -1);
|
|
|
|
if (db_pager_quit) {
|
|
|
|
kdb_jmpbuf(prev_jb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2005-10-02 11:41:12 +00:00
|
|
|
}
|
2006-11-02 11:47:38 +00:00
|
|
|
kdb_jmpbuf(prev_jb);
|
2005-10-02 11:41:12 +00:00
|
|
|
}
|
|
|
|
}
|