db_output.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*-
    2  * Mach Operating System
    3  * Copyright (c) 1991,1990 Carnegie Mellon University
    4  * All Rights Reserved.
    5  *
    6  * Permission to use, copy, modify and distribute this software and its
    7  * documentation is hereby granted, provided that both the copyright
    8  * notice and this permission notice appear in all copies of the
    9  * software, derivative works or modified versions, and any portions
   10  * thereof, and that both notices appear in supporting documentation.
   11  *
   12  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
   13  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
   14  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
   15  *
   16  * Carnegie Mellon requests users of this software to return to
   17  *
   18  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
   19  *  School of Computer Science
   20  *  Carnegie Mellon University
   21  *  Pittsburgh PA 15213-3890
   22  *
   23  * any improvements or extensions that they make and grant Carnegie the
   24  * rights to redistribute these changes.
   25  */
   26 /*
   27  *      Author: David B. Golub, Carnegie Mellon University
   28  *      Date:   7/90
   29  */
   30 
   31 /*
   32  * Printf and character output for debugger.
   33  */
   34 
   35 #include <sys/cdefs.h>
   36 __FBSDID("$FreeBSD$");
   37 
   38 #include <sys/param.h>
   39 #include <sys/systm.h>
   40 #include <sys/cons.h>
   41 #include <sys/kdb.h>
   42 #include <sys/kernel.h>
   43 #include <sys/sysctl.h>
   44 
   45 #include <machine/stdarg.h>
   46 
   47 #include <ddb/ddb.h>
   48 #include <ddb/db_output.h>
   49 
   50 /*
   51  *      Character output - tracks position in line.
   52  *      To do this correctly, we should know how wide
   53  *      the output device is - then we could zero
   54  *      the line position when the output device wraps
   55  *      around to the start of the next line.
   56  *
   57  *      Instead, we count the number of spaces printed
   58  *      since the last printing character so that we
   59  *      don't print trailing spaces.  This avoids most
   60  *      of the wraparounds.
   61  */
   62 static int      db_output_position = 0;         /* output column */
   63 static int      db_last_non_space = 0;          /* last non-space character */
   64 db_expr_t       db_tab_stop_width = 8;          /* how wide are tab stops? */
   65 #define NEXT_TAB(i) \
   66         ((((i) + db_tab_stop_width) / db_tab_stop_width) * db_tab_stop_width)
   67 db_expr_t       db_max_width = 79;              /* output line width */
   68 db_expr_t       db_lines_per_page = 20;         /* lines per page */
   69 volatile int    db_pager_quit;                  /* user requested quit */
   70 static int      db_newlines;                    /* # lines this page */
   71 static int      db_maxlines;                    /* max lines/page when paging */
   72 static int      ddb_use_printf = 0;
   73 SYSCTL_INT(_debug, OID_AUTO, ddb_use_printf, CTLFLAG_RW, &ddb_use_printf, 0,
   74     "use printf for all ddb output");
   75 
   76 static void     db_putchar(int c, void *arg);
   77 static void     db_pager(void);
   78 
   79 /*
   80  * Force pending whitespace.
   81  */
   82 void
   83 db_force_whitespace()
   84 {
   85         register int last_print, next_tab;
   86 
   87         last_print = db_last_non_space;
   88         while (last_print < db_output_position) {
   89             next_tab = NEXT_TAB(last_print);
   90             if (next_tab <= db_output_position) {
   91                 while (last_print < next_tab) { /* DON'T send a tab!!! */
   92                         cnputc(' ');
   93                         db_capture_writech(' ');
   94                         last_print++;
   95                 }
   96             }
   97             else {
   98                 cnputc(' ');
   99                 db_capture_writech(' ');
  100                 last_print++;
  101             }
  102         }
  103         db_last_non_space = db_output_position;
  104 }
  105 
  106 /*
  107  * Output character.  Buffer whitespace.
  108  */
  109 static void
  110 db_putchar(c, arg)
  111         int     c;              /* character to output */
  112         void *  arg;
  113 {
  114 
  115         /*
  116          * If not in the debugger or the user requests it, output data to
  117          * both the console and the message buffer.
  118          */
  119         if (!kdb_active || ddb_use_printf) {
  120                 printf("%c", c);
  121                 if (!kdb_active)
  122                         return;
  123                 if (c == '\r' || c == '\n')
  124                         db_check_interrupt();
  125                 if (c == '\n' && db_maxlines > 0) {
  126                         db_newlines++;
  127                         if (db_newlines >= db_maxlines)
  128                                 db_pager();
  129                 }
  130                 return;
  131         }
  132 
  133         /* Otherwise, output data directly to the console. */
  134         if (c > ' ' && c <= '~') {
  135             /*
  136              * Printing character.
  137              * If we have spaces to print, print them first.
  138              * Use tabs if possible.
  139              */
  140             db_force_whitespace();
  141             cnputc(c);
  142             db_capture_writech(c);
  143             db_output_position++;
  144             db_last_non_space = db_output_position;
  145         }
  146         else if (c == '\n') {
  147             /* Newline */
  148             cnputc(c);
  149             db_capture_writech(c);
  150             db_output_position = 0;
  151             db_last_non_space = 0;
  152             db_check_interrupt();
  153             if (db_maxlines > 0) {
  154                     db_newlines++;
  155                     if (db_newlines >= db_maxlines)
  156                             db_pager();
  157             }
  158         }
  159         else if (c == '\r') {
  160             /* Return */
  161             cnputc(c);
  162             db_capture_writech(c);
  163             db_output_position = 0;
  164             db_last_non_space = 0;
  165             db_check_interrupt();
  166         }
  167         else if (c == '\t') {
  168             /* assume tabs every 8 positions */
  169             db_output_position = NEXT_TAB(db_output_position);
  170         }
  171         else if (c == ' ') {
  172             /* space */
  173             db_output_position++;
  174         }
  175         else if (c == '\007') {
  176             /* bell */
  177             cnputc(c);
  178             /* No need to beep in a log: db_capture_writech(c); */
  179         }
  180         /* other characters are assumed non-printing */
  181 }
  182 
  183 /*
  184  * Turn on the pager.
  185  */
  186 void
  187 db_enable_pager(void)
  188 {
  189         if (db_maxlines == 0) {
  190                 db_maxlines = db_lines_per_page;
  191                 db_newlines = 0;
  192                 db_pager_quit = 0;
  193         }
  194 }
  195 
  196 /*
  197  * Turn off the pager.
  198  */
  199 void
  200 db_disable_pager(void)
  201 {
  202         db_maxlines = 0;
  203 }
  204 
  205 /*
  206  * A simple paging callout function.  It supports several simple more(1)-like
  207  * commands as well as a quit command that sets db_pager_quit which db
  208  * commands can poll to see if they should terminate early.
  209  */
  210 void
  211 db_pager(void)
  212 {
  213         int c, done;
  214 
  215         db_capture_enterpager();
  216         db_printf("--More--\r");
  217         done = 0;
  218         while (!done) {
  219                 c = cngetc();
  220                 switch (c) {
  221                 case 'e':
  222                 case 'j':
  223                 case '\n':
  224                         /* Just one more line. */
  225                         db_maxlines = 1;
  226                         done++;
  227                         break;
  228                 case 'd':
  229                         /* Half a page. */
  230                         db_maxlines = db_lines_per_page / 2;
  231                         done++;
  232                         break;
  233                 case 'f':
  234                 case ' ':
  235                         /* Another page. */
  236                         db_maxlines = db_lines_per_page;
  237                         done++;
  238                         break;
  239                 case 'q':
  240                 case 'Q':
  241                 case 'x':
  242                 case 'X':
  243                         /* Quit */
  244                         db_maxlines = 0;
  245                         db_pager_quit = 1;
  246                         done++;
  247                         break;
  248 #if 0
  249                         /* FALLTHROUGH */
  250                 default:
  251                         cnputc('\007');
  252 #endif
  253                 }
  254         }
  255         db_printf("        ");
  256         db_force_whitespace();
  257         db_printf("\r");
  258         db_newlines = 0;
  259         db_capture_exitpager();
  260 }
  261 
  262 /*
  263  * Return output position
  264  */
  265 int
  266 db_print_position()
  267 {
  268         return (db_output_position);
  269 }
  270 
  271 /*
  272  * Printing
  273  */
  274 void
  275 #if __STDC__
  276 db_printf(const char *fmt, ...)
  277 #else
  278 db_printf(fmt)
  279         const char *fmt;
  280 #endif
  281 {
  282         va_list listp;
  283 
  284         va_start(listp, fmt);
  285         kvprintf (fmt, db_putchar, NULL, db_radix, listp);
  286         va_end(listp);
  287 }
  288 
  289 int db_indent;
  290 
  291 void
  292 #if __STDC__
  293 db_iprintf(const char *fmt,...)
  294 #else
  295 db_iprintf(fmt)
  296         const char *fmt;
  297 #endif
  298 {
  299         register int i;
  300         va_list listp;
  301 
  302         for (i = db_indent; i >= 8; i -= 8)
  303                 db_printf("\t");
  304         while (--i >= 0)
  305                 db_printf(" ");
  306         va_start(listp, fmt);
  307         kvprintf (fmt, db_putchar, NULL, db_radix, listp);
  308         va_end(listp);
  309 }
  310 
  311 /*
  312  * End line if too long.
  313  */
  314 void
  315 db_end_line(int field_width)
  316 {
  317         if (db_output_position + field_width > db_max_width)
  318             db_printf("\n");
  319 }

Cache object: d09aea94d50bf86ecee9e217b50c64d3

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/ddb/db_output.c

FreeBSD/Linux Kernel Cross Reference
sys/ddb/db_output.c