root/ddb/db_command.c

DEFINITIONS

1. db_skip_to_eol
2. db_cmd_search
3. db_cmd_list
4. db_command
5. db_buf_print_cmd
6. db_map_print_cmd
7. db_malloc_print_cmd
8. db_mount_print_cmd
9. db_object_print_cmd
10. db_page_print_cmd
11. db_vnode_print_cmd
12. db_show_panic_cmd
13. db_extent_print_cmd
14. db_pool_print_cmd
15. db_proc_print_cmd
16. db_uvmexp_print_cmd
17. db_machine_commands_install
18. db_help_cmd
19. db_command_loop
20. db_error
21. db_fncall
22. db_boot_sync_cmd
23. db_boot_crash_cmd
24. db_boot_dump_cmd
25. db_boot_halt_cmd
26. db_boot_reboot_cmd
27. db_boot_poweroff_cmd
28. db_dmesg_cmd
29. db_stack_trace_cmd

    1 /*      $OpenBSD: db_command.c,v 1.45 2006/09/30 14:31:28 mickey Exp $  */
    2 /*      $NetBSD: db_command.c,v 1.20 1996/03/30 22:30:05 christos Exp $ */
    4 /* 
    5  * Mach Operating System
    6  * Copyright (c) 1993,1992,1991,1990 Carnegie Mellon University
    7  * All Rights Reserved.
    8  * 
    9  * Permission to use, copy, modify and distribute this software and its
   10  * documentation is hereby granted, provided that both the copyright
   11  * notice and this permission notice appear in all copies of the
   12  * software, derivative works or modified versions, and any portions
   13  * thereof, and that both notices appear in supporting documentation.
   14  * 
   15  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
   16  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
   17  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
   18  * 
   19  * Carnegie Mellon requests users of this software to return to
   20  * 
   21  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
   22  *  School of Computer Science
   23  *  Carnegie Mellon University
   24  *  Pittsburgh PA 15213-3890
   25  * 
   26  * any improvements or extensions that they make and grant Carnegie Mellon
   27  * the rights to redistribute these changes.
   28  */
   30 /*
   31  * Command dispatcher.
   32  */
   33 #include <sys/param.h>
   34 #include <sys/systm.h>
   35 #include <sys/proc.h>
   36 #include <sys/reboot.h>
   37 #include <sys/extent.h>
   38 #include <sys/pool.h>
   39 #include <sys/msgbuf.h>
   40 #include <sys/malloc.h>
   42 #include <uvm/uvm_extern.h>
   43 #include <machine/db_machdep.h>         /* type definitions */
   45 #include <ddb/db_lex.h>
   46 #include <ddb/db_output.h>
   47 #include <ddb/db_command.h>
   48 #include <ddb/db_break.h>
   49 #include <ddb/db_watch.h>
   50 #include <ddb/db_run.h>
   51 #include <ddb/db_variables.h>
   52 #include <ddb/db_interface.h>
   53 #include <ddb/db_sym.h>
   54 #include <ddb/db_extern.h>
   56 #include <uvm/uvm_ddb.h>
   58 /*
   59  * Exported global variables
   60  */
boolean_t       db_cmd_loop_done;
label_t         *db_recover;
   64 /*
   65  * if 'ed' style: 'dot' is set at start of last item printed,
   66  * and '+' points to next line.
   67  * Otherwise: 'dot' points to next item, '..' points to last.
   68  */
boolean_t       db_ed_style = TRUE;
db_addr_t       db_dot;         /* current location */
db_addr_t       db_last_addr;   /* last explicit address typed */
db_addr_t       db_prev;        /* last address examined
   74                                    or written */
db_addr_t       db_next;        /* next address to be examined
   76                                    or written */
   78 /*
   79  * Utility routine - discard tokens through end-of-line.
   80  */
   81 void
db_skip_to_eol(void)
   83 {
   84         int     t;
   85         do {
t = db_read_token();
   87         } while (t != tEOL);
   88 }
   90 /*
   91  * Results of command search.
   92  */
   93 #define CMD_UNIQUE      0
   94 #define CMD_FOUND       1
   95 #define CMD_NONE        2
   96 #define CMD_AMBIGUOUS   3
   98 /*
   99  * Search for command prefix.
  100  */
  101 int
db_cmd_search(char *name, struct db_command *table, struct db_command **cmdp)
  103 {
  104         struct db_command       *cmd;
  105         int                     result = CMD_NONE;
  107         for (cmd = table; cmd->name != 0; cmd++) {
  108             char *lp;
  109             char *rp;
  110             int  c;
lp = name;
rp = cmd->name;
  114             while ((c = *lp) == *rp) {
  115                 if (c == 0) {
  116                     /* complete match */
  117                     *cmdp = cmd;
  118                     return (CMD_UNIQUE);
  119                 }
lp++;
rp++;
  122             }
  123             if (c == 0) {
  124                 /* end of name, not end of command -
  125                    partial match */
  126                 if (result == CMD_FOUND) {
result = CMD_AMBIGUOUS;
  128                     /* but keep looking for a full match -
  129                        this lets us match single letters */
  130                 }
  131                 else {
  132                     *cmdp = cmd;
result = CMD_FOUND;
  134                 }
  135             }
  136         }
  137         return (result);
  138 }
  140 void
db_cmd_list(struct db_command *table)
  142 {
  143         struct db_command *cmd;
  145         for (cmd = table; cmd->name != 0; cmd++) {
db_printf("%-12s", cmd->name);
db_end_line(12);
  148         }
  149 }
  151 void
db_command(struct db_command **last_cmdp, struct db_command *cmd_table)
  153 {
  154         struct db_command       *cmd;
  155         int             t;
  156         char            modif[TOK_STRING_SIZE];
db_expr_t       addr, count;
boolean_t       have_addr = FALSE;
  159         int             result;
t = db_read_token();
  162         if (t == tEOL) {
  163             /* empty line repeats last command, at 'next' */
cmd = *last_cmdp;
addr = (db_expr_t)db_next;
have_addr = FALSE;
count = 1;
modif[0] = '\0';
  169         }
  170         else if (t == tEXCL) {
db_fncall(0, 0, 0, NULL);
  172             return;
  173         }
  174         else if (t != tIDENT) {
db_printf("?\n");
db_flush_lex();
  177             return;
  178         }
  179         else {
  180             /*
  181              * Search for command
  182              */
  183             while (cmd_table) {
result = db_cmd_search(db_tok_string,
cmd_table,
  186                                        &cmd);
  187                 switch (result) {
  188                     case CMD_NONE:
db_printf("No such command\n");
db_flush_lex();
  191                         return;
  192                     case CMD_AMBIGUOUS:
db_printf("Ambiguous\n");
db_flush_lex();
  195                         return;
  196                     default:
  197                         break;
  198                 }
  199                 if ((cmd_table = cmd->more) != 0) {
t = db_read_token();
  201                     if (t != tIDENT) {
db_cmd_list(cmd_table);
db_flush_lex();
  204                         return;
  205                     }
  206                 }
  207             }
  209             if ((cmd->flag & CS_OWN) == 0) {
  210                 /*
  211                  * Standard syntax:
  212                  * command [/modifier] [addr] [,count]
  213                  */
t = db_read_token();
  215                 if (t == tSLASH) {
t = db_read_token();
  217                     if (t != tIDENT) {
db_printf("Bad modifier\n");
db_flush_lex();
  220                         return;
  221                     }
db_strlcpy(modif, db_tok_string, sizeof(modif));
  223                 }
  224                 else {
db_unread_token(t);
modif[0] = '\0';
  227                 }
  229                 if (db_expression(&addr)) {
db_dot = (db_addr_t) addr;
db_last_addr = db_dot;
have_addr = TRUE;
  233                 }
  234                 else {
addr = (db_expr_t) db_dot;
have_addr = FALSE;
  237                 }
t = db_read_token();
  239                 if (t == tCOMMA) {
  240                     if (!db_expression(&count)) {
db_printf("Count missing\n");
db_flush_lex();
  243                         return;
  244                     }
  245                 }
  246                 else {
db_unread_token(t);
count = -1;
  249                 }
  250                 if ((cmd->flag & CS_MORE) == 0) {
db_skip_to_eol();
  252                 }
  253             }
  254         }
  255         *last_cmdp = cmd;
  256         if (cmd != 0) {
  257             /*
  258              * Execute the command.
  259              */
  260             (*cmd->fcn)(addr, have_addr, count, modif);
  262             if (cmd->flag & CS_SET_DOT) {
  263                 /*
  264                  * If command changes dot, set dot to
  265                  * previous address displayed (if 'ed' style).
  266                  */
  267                 if (db_ed_style) {
db_dot = db_prev;
  269                 }
  270                 else {
db_dot = db_next;
  272                 }
  273             }
  274             else {
  275                 /*
  276                  * If command does not change dot,
  277                  * set 'next' location to be the same.
  278                  */
db_next = db_dot;
  280             }
  281         }
  282 }
  284 /*ARGSUSED*/
  285 void
db_buf_print_cmd(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
  287 {
boolean_t full = FALSE;
  290         if (modif[0] == 'f')
full = TRUE;
vfs_buf_print((struct buf *) addr, full, db_printf);
  294 }
  296 /*ARGSUSED*/
  297 void
db_map_print_cmd(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
  299 {
boolean_t full = FALSE;
  302         if (modif[0] == 'f')
full = TRUE;
uvm_map_printit((struct vm_map *) addr, full, db_printf);
  306 }
  308 /*ARGSUSED*/
  309 void
db_malloc_print_cmd(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
  311 {
  312 #if defined(MALLOC_DEBUG)
  313         extern void debug_malloc_printit(int (*)(const char *, ...), vaddr_t);
  315         if (!have_addr)
addr = 0;
debug_malloc_printit(db_printf, (vaddr_t)addr);
  319 #else
malloc_printit(db_printf);
  321 #endif
  322 }
  324 /*ARGSUSED*/
  325 void
db_mount_print_cmd(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
  327 {
boolean_t full = FALSE;
  330         if (modif[0] == 'f')
full = TRUE;
vfs_mount_print((struct mount *) addr, full, db_printf);
  334 }
  336 /*ARGSUSED*/
  337 void
db_object_print_cmd(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
  339 {
boolean_t full = FALSE;
  342         if (modif[0] == 'f')
full = TRUE;
uvm_object_printit((struct uvm_object *) addr, full, db_printf);
  346 }
  348 /*ARGSUSED*/
  349 void
db_page_print_cmd(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
  351 {
boolean_t full = FALSE;
  354         if (modif[0] == 'f')
full = TRUE;
uvm_page_printit((struct vm_page *) addr, full, db_printf);
  358 }
  360 /*ARGSUSED*/
  361 void     
db_vnode_print_cmd(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
  363 {
boolean_t full = FALSE;
  366         if (modif[0] == 'f')
full = TRUE;
vfs_vnode_print((struct vnode *) addr, full, db_printf);
  370 }
  372 /*ARGSUSED*/
  373 void
db_show_panic_cmd(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
  375 {
  376         if (panicstr)
db_printf("%s\n", panicstr);
  378         else
db_printf("the kernel did not panic\n");        /* yet */
  380 }
  382 /*ARGSUSED*/
  383 void
db_extent_print_cmd(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
  385 {
extent_print_all();
  387 }
  389 /*ARGSUSED*/
  390 void
db_pool_print_cmd(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
  392 {
pool_printit((struct pool *)addr, modif, db_printf);
  394 }
  396 /*ARGSUSED*/
  397 void
db_proc_print_cmd(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
  399 {
  400         if (!have_addr)
addr = (db_expr_t)curproc;
proc_printit((struct proc *)addr, modif, db_printf);
  404 }
  406 /*ARGSUSED*/
  407 void
db_uvmexp_print_cmd(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
  409 {
uvmexp_print(db_printf);
  411 }
  413 /*
  414  * 'show' commands
  415  */
  417 struct db_command db_show_all_cmds[] = {
  418         { "procs",      db_show_all_procs,      0, NULL },
  419         { "callout",    db_show_callout,        0, NULL },
  420         { "pools",      db_show_all_pools,      0, NULL },
  421         { NULL,         NULL,                   0, NULL }
  422 };
  424 struct db_command db_show_cmds[] = {
  425         { "all",        NULL,                   0,      db_show_all_cmds },
  426         { "breaks",     db_listbreak_cmd,       0,      NULL },
  427         { "buf",        db_buf_print_cmd,       0,      NULL },
  428         { "extents",    db_extent_print_cmd,    0,      NULL },
  429         { "malloc",     db_malloc_print_cmd,    0,      NULL },
  430         { "map",        db_map_print_cmd,       0,      NULL },
  431         { "mount",      db_mount_print_cmd,     0,      NULL },
  432         { "object",     db_object_print_cmd,    0,      NULL },
  433         { "page",       db_page_print_cmd,      0,      NULL },
  434         { "panic",      db_show_panic_cmd,      0,      NULL },
  435         { "pool",       db_pool_print_cmd,      0,      NULL },
  436         { "proc",       db_proc_print_cmd,      0,      NULL },
  437         { "registers",  db_show_regs,           0,      NULL },
  438         { "uvmexp",     db_uvmexp_print_cmd,    0,      NULL },
  439         { "vnode",      db_vnode_print_cmd,     0,      NULL },
  440         { "watches",    db_listwatch_cmd,       0,      NULL },
  441         { NULL,         NULL,                   0,      NULL }
  442 };
  444 struct db_command db_boot_cmds[] = {
  445         { "sync",       db_boot_sync_cmd,       0,      0 },
  446         { "crash",      db_boot_crash_cmd,      0,      0 },
  447         { "dump",       db_boot_dump_cmd,       0,      0 },
  448         { "halt",       db_boot_halt_cmd,       0,      0 },
  449         { "reboot",     db_boot_reboot_cmd,     0,      0 },
  450         { "poweroff",   db_boot_poweroff_cmd,   0,      0 },
  451         { NULL, }
  452 };
  454 struct db_command db_command_table[] = {
  455 #ifdef DB_MACHINE_COMMANDS
  456   /* this must be the first entry, if it exists */
  457         { "machine",    NULL,                   0,              NULL},
  458 #endif
  459         { "print",      db_print_cmd,           0,              NULL },
  460         { "examine",    db_examine_cmd,         CS_SET_DOT,     NULL },
  461         { "x",          db_examine_cmd,         CS_SET_DOT,     NULL },
  462         { "search",     db_search_cmd,          CS_OWN|CS_SET_DOT, NULL },
  463         { "set",        db_set_cmd,             CS_OWN,         NULL },
  464         { "write",      db_write_cmd,           CS_MORE|CS_SET_DOT, NULL },
  465         { "w",          db_write_cmd,           CS_MORE|CS_SET_DOT, NULL },
  466         { "delete",     db_delete_cmd,          0,              NULL },
  467         { "d",          db_delete_cmd,          0,              NULL },
  468         { "break",      db_breakpoint_cmd,      0,              NULL },
  469         { "dwatch",     db_deletewatch_cmd,     0,              NULL },
  470         { "watch",      db_watchpoint_cmd,      CS_MORE,        NULL },
  471         { "step",       db_single_step_cmd,     0,              NULL },
  472         { "s",          db_single_step_cmd,     0,              NULL },
  473         { "continue",   db_continue_cmd,        0,              NULL },
  474         { "c",          db_continue_cmd,        0,              NULL },
  475         { "until",      db_trace_until_call_cmd,0,              NULL },
  476         { "next",       db_trace_until_matching_cmd,0,          NULL },
  477         { "match",      db_trace_until_matching_cmd,0,          NULL },
  478         { "trace",      db_stack_trace_cmd,     0,              NULL },
  479         { "call",       db_fncall,              CS_OWN,         NULL },
  480         { "ps",         db_show_all_procs,      0,              NULL },
  481         { "callout",    db_show_callout,        0,              NULL },
  482         { "show",       NULL,                   0,              db_show_cmds },
  483         { "boot",       NULL,                   0,              db_boot_cmds },
  484         { "help",       db_help_cmd,            0,              NULL },
  485         { "hangman",    db_hangman,             0,              NULL },
  486         { "dmesg",      db_dmesg_cmd,           0,              NULL },
  487         { NULL,         NULL,                   0,              NULL }
  488 };
  490 #ifdef DB_MACHINE_COMMANDS
  492 /* this function should be called to install the machine dependent
  493    commands. It should be called before the debugger is enabled  */
  494 void db_machine_commands_install(struct db_command *ptr)
  495 {
db_command_table[0].more = ptr;
  497   return;
  498 }
  500 #endif
  502 struct db_command       *db_last_command = 0;
  504 void
db_help_cmd(db_expr_t addr, int haddr, db_expr_t count, char *modif)
  506 {
db_cmd_list(db_command_table);
  508 }
  510 void
db_command_loop(void)
  512 {
label_t         db_jmpbuf;
label_t         *savejmp;
  515         extern int      db_output_line;
  517         /*
  518          * Initialize 'prev' and 'next' to dot.
  519          */
db_prev = db_dot;
db_next = db_dot;
db_cmd_loop_done = 0;
savejmp = db_recover;
db_recover = &db_jmpbuf;
  527         (void) setjmp(&db_jmpbuf);
  529         while (!db_cmd_loop_done) {
  531                 if (db_print_position() != 0)
db_printf("\n");
db_output_line = 0;
  535 #ifdef MULTIPROCESSOR
db_printf("ddb{%d}> ", CPU_INFO_UNIT(curcpu()));
  537 #else
db_printf("ddb> ");
  539 #endif
  540                 (void) db_read_line();
db_command(&db_last_command, db_command_table);
  543         }
db_recover = savejmp;
  546 }
  548 void
db_error(char *s)
  550 {
  551         if (s)
db_printf("%s", s);
db_flush_lex();
longjmp(db_recover);
  555 }
  558 /*
  559  * Call random function:
  560  * !expr(arg,arg,arg)
  561  */
  562 /*ARGSUSED*/
  563 void
db_fncall(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
  565 {
db_expr_t       fn_addr;
  567 #define MAXARGS         11
db_expr_t       args[MAXARGS];
  569         int             nargs = 0;
db_expr_t       retval;
db_expr_t       (*func)(db_expr_t, ...);
  572         int             t;
  574         if (!db_expression(&fn_addr)) {
db_printf("Bad function\n");
db_flush_lex();
  577             return;
  578         }
func = (db_expr_t (*)(db_expr_t, ...)) fn_addr;
t = db_read_token();
  582         if (t == tLPAREN) {
  583             if (db_expression(&args[0])) {
nargs++;
  585                 while ((t = db_read_token()) == tCOMMA) {
  586                     if (nargs == MAXARGS) {
db_printf("Too many arguments\n");
db_flush_lex();
  589                         return;
  590                     }
  591                     if (!db_expression(&args[nargs])) {
db_printf("Argument missing\n");
db_flush_lex();
  594                         return;
  595                     }
nargs++;
  597                 }
db_unread_token(t);
  599             }
  600             if (db_read_token() != tRPAREN) {
db_printf("?\n");
db_flush_lex();
  603                 return;
  604             }
  605         }
db_skip_to_eol();
  608         while (nargs < MAXARGS) {
args[nargs++] = 0;
  610         }
retval = (*func)(args[0], args[1], args[2], args[3], args[4],
args[5], args[6], args[7], args[8], args[9]);
db_printf("%#n\n", retval);
  615 }
  617 void
db_boot_sync_cmd(db_expr_t addr, int haddr, db_expr_t count, char *modif)
  619 {
boot(RB_AUTOBOOT | RB_TIMEBAD | RB_USERREQ);
  621 }
  623 void
db_boot_crash_cmd(db_expr_t addr, int haddr, db_expr_t count, char *modif)
  625 {
boot(RB_NOSYNC | RB_DUMP | RB_TIMEBAD | RB_USERREQ);
  627 }
  629 void
db_boot_dump_cmd(db_expr_t addr, int haddr, db_expr_t count, char *modif)
  631 {
boot(RB_DUMP | RB_TIMEBAD | RB_USERREQ);
  633 }
  635 void
db_boot_halt_cmd(db_expr_t addr, int haddr, db_expr_t count, char *modif)
  637 {
boot(RB_NOSYNC | RB_HALT | RB_TIMEBAD | RB_USERREQ);
  639 }
  641 void
db_boot_reboot_cmd(db_expr_t addr, int haddr, db_expr_t count, char *modif)
  643 {
boot(RB_AUTOBOOT | RB_NOSYNC | RB_TIMEBAD | RB_USERREQ);
  645 }
  647 void
db_boot_poweroff_cmd(db_expr_t addr, int haddr, db_expr_t count, char *modif)
  649 {
boot(RB_NOSYNC | RB_HALT | RB_POWERDOWN | RB_TIMEBAD | RB_USERREQ);
  651 }
  653 void
db_dmesg_cmd(db_expr_t addr, int haddr, db_expr_t count, char *modif)
  655 {
  656         int i, off;
  657         char *p;
  659         if (!msgbufp || msgbufp->msg_magic != MSG_MAGIC)
  660                 return;
off = msgbufp->msg_bufx;
  662         if (off > msgbufp->msg_bufs)
off = 0;
  664         for (i = 0, p = msgbufp->msg_bufc + off;
i < msgbufp->msg_bufs; i++, p++) {
  666                 if (p >= msgbufp->msg_bufc + msgbufp->msg_bufs)
p = msgbufp->msg_bufc;
  668                 if (*p != '\0')
db_putchar(*p);
  670         }
db_putchar('\n');
  672 }
  674 void
db_stack_trace_cmd(db_expr_t addr, boolean_t have_addr, db_expr_t count,
  676     char *modif)
  677 {
db_stack_trace_print(addr, have_addr, count, modif, db_printf);
  679 }