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 "opt_ddb.h"
   39 
   40 #include <sys/param.h>
   41 #include <sys/systm.h>
   42 #include <sys/cons.h>
   43 #include <sys/kdb.h>
   44 #include <sys/kernel.h>
   45 #include <sys/sysctl.h>
   46 
   47 #include <machine/stdarg.h>
   48 
   49 #include <ddb/ddb.h>
   50 #include <ddb/db_output.h>
   51 
   52 struct dbputchar_arg {
   53         size_t  da_nbufr;
   54         size_t  da_remain;
   55         char    *da_pbufr;
   56         char    *da_pnext;
   57 };
   58 
   59 /*
   60  *      Character output - tracks position in line.
   61  *      To do this correctly, we should know how wide
   62  *      the output device is - then we could zero
   63  *      the line position when the output device wraps
   64  *      around to the start of the next line.
   65  *
   66  *      Instead, we count the number of spaces printed
   67  *      since the last printing character so that we
   68  *      don't print trailing spaces.  This avoids most
   69  *      of the wraparounds.
   70  */
   71 static int      db_output_position = 0;         /* output column */
   72 static int      db_last_non_space = 0;          /* last non-space character */
   73 db_expr_t       db_tab_stop_width = 8;          /* how wide are tab stops? */
   74 #define NEXT_TAB(i) rounddown((i) + db_tab_stop_width, db_tab_stop_width)
   75 db_expr_t       db_max_width = 79;              /* output line width */
   76 db_expr_t       db_lines_per_page = 20;         /* lines per page */
   77 volatile int    db_pager_quit;                  /* user requested quit */
   78 static int      db_newlines;                    /* # lines this page */
   79 static int      db_maxlines;                    /* max lines/page when paging */
   80 static int      ddb_use_printf = 0;
   81 SYSCTL_INT(_debug, OID_AUTO, ddb_use_printf, CTLFLAG_RW, &ddb_use_printf, 0,
   82     "use printf for all ddb output");
   83 
   84 static void     db_putc(int c);
   85 static void     db_puts(const char *str);
   86 static void     db_putchar(int c, void *arg);
   87 static void     db_pager(void);
   88 
   89 /*
   90  * Force pending whitespace.
   91  */
   92 void
   93 db_force_whitespace(void)
   94 {
   95         int last_print, next_tab;
   96 
   97         last_print = db_last_non_space;
   98         while (last_print < db_output_position) {
   99             next_tab = NEXT_TAB(last_print);
  100             if (next_tab <= db_output_position) {
  101                 while (last_print < next_tab) { /* DON'T send a tab!!! */
  102                         cnputc(' ');
  103                         db_capture_writech(' ');
  104                         last_print++;
  105                 }
  106             }
  107             else {
  108                 cnputc(' ');
  109                 db_capture_writech(' ');
  110                 last_print++;
  111             }
  112         }
  113         db_last_non_space = db_output_position;
  114 }
  115 
  116 /*
  117  * Output character.  Buffer whitespace.
  118  */
  119 static void
  120 db_putchar(int c, void *arg)
  121 {
  122         struct dbputchar_arg *dap = arg;
  123 
  124         if (dap->da_pbufr == NULL) {
  125 
  126                  /* No bufferized output is provided. */
  127                 db_putc(c);
  128         } else {
  129 
  130                 *dap->da_pnext++ = c;
  131                 dap->da_remain--;
  132 
  133                 /* Leave always the buffer 0 terminated. */
  134                 *dap->da_pnext = '\0';
  135 
  136                 /* Check if the buffer needs to be flushed. */
  137                 if (dap->da_remain < 2 || c == '\n') {
  138                         db_puts(dap->da_pbufr);
  139                         dap->da_pnext = dap->da_pbufr;
  140                         dap->da_remain = dap->da_nbufr;
  141                         *dap->da_pnext = '\0';
  142                 }
  143         }
  144 }
  145 
  146 static void
  147 db_putc(int c)
  148 {
  149 
  150         /*
  151          * If not in the debugger or the user requests it, output data to
  152          * both the console and the message buffer.
  153          */
  154         if (!kdb_active || ddb_use_printf) {
  155                 printf("%c", c);
  156                 if (!kdb_active)
  157                         return;
  158                 if (c == '\r' || c == '\n')
  159                         db_check_interrupt();
  160                 if (c == '\n' && db_maxlines > 0) {
  161                         db_newlines++;
  162                         if (db_newlines >= db_maxlines)
  163                                 db_pager();
  164                 }
  165                 return;
  166         }
  167 
  168         /* Otherwise, output data directly to the console. */
  169         if (c > ' ' && c <= '~') {
  170             /*
  171              * Printing character.
  172              * If we have spaces to print, print them first.
  173              * Use tabs if possible.
  174              */
  175             db_force_whitespace();
  176             cnputc(c);
  177             db_capture_writech(c);
  178             db_output_position++;
  179             db_last_non_space = db_output_position;
  180         }
  181         else if (c == '\n') {
  182             /* Newline */
  183             cnputc(c);
  184             db_capture_writech(c);
  185             db_output_position = 0;
  186             db_last_non_space = 0;
  187             db_check_interrupt();
  188             if (db_maxlines > 0) {
  189                     db_newlines++;
  190                     if (db_newlines >= db_maxlines)
  191                             db_pager();
  192             }
  193         }
  194         else if (c == '\r') {
  195             /* Return */
  196             cnputc(c);
  197             db_capture_writech(c);
  198             db_output_position = 0;
  199             db_last_non_space = 0;
  200             db_check_interrupt();
  201         }
  202         else if (c == '\t') {
  203             /* assume tabs every 8 positions */
  204             db_output_position = NEXT_TAB(db_output_position);
  205         }
  206         else if (c == ' ') {
  207             /* space */
  208             db_output_position++;
  209         }
  210         else if (c == '\007') {
  211             /* bell */
  212             cnputc(c);
  213             /* No need to beep in a log: db_capture_writech(c); */
  214         }
  215         /* other characters are assumed non-printing */
  216 }
  217 
  218 static void
  219 db_puts(const char *str)
  220 {
  221         int i;
  222 
  223         for (i = 0; str[i] != '\0'; i++)
  224                 db_putc(str[i]);
  225 }
  226 
  227 /*
  228  * Turn on the pager.
  229  */
  230 void
  231 db_enable_pager(void)
  232 {
  233         if (db_maxlines == 0) {
  234                 db_maxlines = db_lines_per_page;
  235                 db_newlines = 0;
  236                 db_pager_quit = 0;
  237         }
  238 }
  239 
  240 /*
  241  * Turn off the pager.
  242  */
  243 void
  244 db_disable_pager(void)
  245 {
  246         db_maxlines = 0;
  247 }
  248 
  249 /*
  250  * A simple paging callout function.  It supports several simple more(1)-like
  251  * commands as well as a quit command that sets db_pager_quit which db
  252  * commands can poll to see if they should terminate early.
  253  */
  254 void
  255 db_pager(void)
  256 {
  257         int c, done;
  258 
  259         db_capture_enterpager();
  260         db_printf("--More--\r");
  261         done = 0;
  262         while (!done) {
  263                 c = cngetc();
  264                 switch (c) {
  265                 case 'e':
  266                 case 'j':
  267                 case '\n':
  268                         /* Just one more line. */
  269                         db_maxlines = 1;
  270                         done++;
  271                         break;
  272                 case 'd':
  273                         /* Half a page. */
  274                         db_maxlines = db_lines_per_page / 2;
  275                         done++;
  276                         break;
  277                 case 'f':
  278                 case ' ':
  279                         /* Another page. */
  280                         db_maxlines = db_lines_per_page;
  281                         done++;
  282                         break;
  283                 case 'q':
  284                 case 'Q':
  285                 case 'x':
  286                 case 'X':
  287                         /* Quit */
  288                         db_maxlines = 0;
  289                         db_pager_quit = 1;
  290                         done++;
  291                         break;
  292 #if 0
  293                         /* FALLTHROUGH */
  294                 default:
  295                         cnputc('\007');
  296 #endif
  297                 }
  298         }
  299         db_printf("        ");
  300         db_force_whitespace();
  301         db_printf("\r");
  302         db_newlines = 0;
  303         db_capture_exitpager();
  304 }
  305 
  306 /*
  307  * Return output position
  308  */
  309 int
  310 db_print_position(void)
  311 {
  312         return (db_output_position);
  313 }
  314 
  315 /*
  316  * Printing
  317  */
  318 int
  319 db_printf(const char *fmt, ...)
  320 {
  321 #ifdef DDB_BUFR_SIZE
  322         char bufr[DDB_BUFR_SIZE];
  323 #endif
  324         struct dbputchar_arg dca;
  325         va_list listp;
  326         int retval;
  327 
  328 #ifdef DDB_BUFR_SIZE
  329         dca.da_pbufr = bufr;
  330         dca.da_pnext = dca.da_pbufr;
  331         dca.da_nbufr = sizeof(bufr);
  332         dca.da_remain = sizeof(bufr);
  333         *dca.da_pnext = '\0';
  334 #else
  335         dca.da_pbufr = NULL;
  336 #endif
  337 
  338         va_start(listp, fmt);
  339         retval = kvprintf (fmt, db_putchar, &dca, db_radix, listp);
  340         va_end(listp);
  341 
  342 #ifdef DDB_BUFR_SIZE
  343         if (*dca.da_pbufr != '\0')
  344                 db_puts(dca.da_pbufr);
  345 #endif
  346         return (retval);
  347 }
  348 
  349 int db_indent;
  350 
  351 void
  352 db_iprintf(const char *fmt,...)
  353 {
  354 #ifdef DDB_BUFR_SIZE
  355         char bufr[DDB_BUFR_SIZE];
  356 #endif
  357         struct dbputchar_arg dca;
  358         int i;
  359         va_list listp;
  360 
  361         for (i = db_indent; i >= 8; i -= 8)
  362                 db_printf("\t");
  363         while (--i >= 0)
  364                 db_printf(" ");
  365 
  366 #ifdef DDB_BUFR_SIZE
  367         dca.da_pbufr = bufr;
  368         dca.da_pnext = dca.da_pbufr;
  369         dca.da_nbufr = sizeof(bufr);
  370         dca.da_remain = sizeof(bufr);
  371         *dca.da_pnext = '\0';
  372 #else
  373         dca.da_pbufr = NULL;
  374 #endif
  375 
  376         va_start(listp, fmt);
  377         kvprintf (fmt, db_putchar, &dca, db_radix, listp);
  378         va_end(listp);
  379 
  380 #ifdef DDB_BUFR_SIZE
  381         if (*dca.da_pbufr != '\0')
  382                 db_puts(dca.da_pbufr);
  383 #endif
  384 }
  385 
  386 /*
  387  * End line if too long.
  388  */
  389 void
  390 db_end_line(int field_width)
  391 {
  392         if (db_output_position + field_width > db_max_width)
  393             db_printf("\n");
  394 }
Cache object: 1fc4e4f1dfd3313c60d5b0a21561bb48
[ 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
