linux/kernel/debug/kdb/kdb_io.c
<<
>>
Prefs
   1/*
   2 * Kernel Debugger Architecture Independent Console I/O handler
   3 *
   4 * This file is subject to the terms and conditions of the GNU General Public
   5 * License.  See the file "COPYING" in the main directory of this archive
   6 * for more details.
   7 *
   8 * Copyright (c) 1999-2006 Silicon Graphics, Inc.  All Rights Reserved.
   9 * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
  10 */
  11
  12#include <linux/module.h>
  13#include <linux/types.h>
  14#include <linux/ctype.h>
  15#include <linux/kernel.h>
  16#include <linux/init.h>
  17#include <linux/kdev_t.h>
  18#include <linux/console.h>
  19#include <linux/string.h>
  20#include <linux/sched.h>
  21#include <linux/smp.h>
  22#include <linux/nmi.h>
  23#include <linux/delay.h>
  24#include <linux/kgdb.h>
  25#include <linux/kdb.h>
  26#include <linux/kallsyms.h>
  27#include "kdb_private.h"
  28
  29#define CMD_BUFLEN 256
  30char kdb_prompt_str[CMD_BUFLEN];
  31
  32int kdb_trap_printk;
  33int kdb_printf_cpu = -1;
  34
  35static int kgdb_transition_check(char *buffer)
  36{
  37        if (buffer[0] != '+' && buffer[0] != '$') {
  38                KDB_STATE_SET(KGDB_TRANS);
  39                kdb_printf("%s", buffer);
  40        } else {
  41                int slen = strlen(buffer);
  42                if (slen > 3 && buffer[slen - 3] == '#') {
  43                        kdb_gdb_state_pass(buffer);
  44                        strcpy(buffer, "kgdb");
  45                        KDB_STATE_SET(DOING_KGDB);
  46                        return 1;
  47                }
  48        }
  49        return 0;
  50}
  51
  52static int kdb_read_get_key(char *buffer, size_t bufsize)
  53{
  54#define ESCAPE_UDELAY 1000
  55#define ESCAPE_DELAY (2*1000000/ESCAPE_UDELAY) /* 2 seconds worth of udelays */
  56        char escape_data[5];    /* longest vt100 escape sequence is 4 bytes */
  57        char *ped = escape_data;
  58        int escape_delay = 0;
  59        get_char_func *f, *f_escape = NULL;
  60        int key;
  61
  62        for (f = &kdb_poll_funcs[0]; ; ++f) {
  63                if (*f == NULL) {
  64                        /* Reset NMI watchdog once per poll loop */
  65                        touch_nmi_watchdog();
  66                        f = &kdb_poll_funcs[0];
  67                }
  68                if (escape_delay == 2) {
  69                        *ped = '\0';
  70                        ped = escape_data;
  71                        --escape_delay;
  72                }
  73                if (escape_delay == 1) {
  74                        key = *ped++;
  75                        if (!*ped)
  76                                --escape_delay;
  77                        break;
  78                }
  79                key = (*f)();
  80                if (key == -1) {
  81                        if (escape_delay) {
  82                                udelay(ESCAPE_UDELAY);
  83                                --escape_delay;
  84                        }
  85                        continue;
  86                }
  87                if (bufsize <= 2) {
  88                        if (key == '\r')
  89                                key = '\n';
  90                        *buffer++ = key;
  91                        *buffer = '\0';
  92                        return -1;
  93                }
  94                if (escape_delay == 0 && key == '\e') {
  95                        escape_delay = ESCAPE_DELAY;
  96                        ped = escape_data;
  97                        f_escape = f;
  98                }
  99                if (escape_delay) {
 100                        *ped++ = key;
 101                        if (f_escape != f) {
 102                                escape_delay = 2;
 103                                continue;
 104                        }
 105                        if (ped - escape_data == 1) {
 106                                /* \e */
 107                                continue;
 108                        } else if (ped - escape_data == 2) {
 109                                /* \e<something> */
 110                                if (key != '[')
 111                                        escape_delay = 2;
 112                                continue;
 113                        } else if (ped - escape_data == 3) {
 114                                /* \e[<something> */
 115                                int mapkey = 0;
 116                                switch (key) {
 117                                case 'A': /* \e[A, up arrow */
 118                                        mapkey = 16;
 119                                        break;
 120                                case 'B': /* \e[B, down arrow */
 121                                        mapkey = 14;
 122                                        break;
 123                                case 'C': /* \e[C, right arrow */
 124                                        mapkey = 6;
 125                                        break;
 126                                case 'D': /* \e[D, left arrow */
 127                                        mapkey = 2;
 128                                        break;
 129                                case '1': /* dropthrough */
 130                                case '3': /* dropthrough */
 131                                /* \e[<1,3,4>], may be home, del, end */
 132                                case '4':
 133                                        mapkey = -1;
 134                                        break;
 135                                }
 136                                if (mapkey != -1) {
 137                                        if (mapkey > 0) {
 138                                                escape_data[0] = mapkey;
 139                                                escape_data[1] = '\0';
 140                                        }
 141                                        escape_delay = 2;
 142                                }
 143                                continue;
 144                        } else if (ped - escape_data == 4) {
 145                                /* \e[<1,3,4><something> */
 146                                int mapkey = 0;
 147                                if (key == '~') {
 148                                        switch (escape_data[2]) {
 149                                        case '1': /* \e[1~, home */
 150                                                mapkey = 1;
 151                                                break;
 152                                        case '3': /* \e[3~, del */
 153                                                mapkey = 4;
 154                                                break;
 155                                        case '4': /* \e[4~, end */
 156                                                mapkey = 5;
 157                                                break;
 158                                        }
 159                                }
 160                                if (mapkey > 0) {
 161                                        escape_data[0] = mapkey;
 162                                        escape_data[1] = '\0';
 163                                }
 164                                escape_delay = 2;
 165                                continue;
 166                        }
 167                }
 168                break;  /* A key to process */
 169        }
 170        return key;
 171}
 172
 173/*
 174 * kdb_read
 175 *
 176 *      This function reads a string of characters, terminated by
 177 *      a newline, or by reaching the end of the supplied buffer,
 178 *      from the current kernel debugger console device.
 179 * Parameters:
 180 *      buffer  - Address of character buffer to receive input characters.
 181 *      bufsize - size, in bytes, of the character buffer
 182 * Returns:
 183 *      Returns a pointer to the buffer containing the received
 184 *      character string.  This string will be terminated by a
 185 *      newline character.
 186 * Locking:
 187 *      No locks are required to be held upon entry to this
 188 *      function.  It is not reentrant - it relies on the fact
 189 *      that while kdb is running on only one "master debug" cpu.
 190 * Remarks:
 191 *
 192 * The buffer size must be >= 2.  A buffer size of 2 means that the caller only
 193 * wants a single key.
 194 *
 195 * An escape key could be the start of a vt100 control sequence such as \e[D
 196 * (left arrow) or it could be a character in its own right.  The standard
 197 * method for detecting the difference is to wait for 2 seconds to see if there
 198 * are any other characters.  kdb is complicated by the lack of a timer service
 199 * (interrupts are off), by multiple input sources and by the need to sometimes
 200 * return after just one key.  Escape sequence processing has to be done as
 201 * states in the polling loop.
 202 */
 203
 204static char *kdb_read(char *buffer, size_t bufsize)
 205{
 206        char *cp = buffer;
 207        char *bufend = buffer+bufsize-2;        /* Reserve space for newline
 208                                                 * and null byte */
 209        char *lastchar;
 210        char *p_tmp;
 211        char tmp;
 212        static char tmpbuffer[CMD_BUFLEN];
 213        int len = strlen(buffer);
 214        int len_tmp;
 215        int tab = 0;
 216        int count;
 217        int i;
 218        int diag, dtab_count;
 219        int key, buf_size, ret;
 220
 221
 222        diag = kdbgetintenv("DTABCOUNT", &dtab_count);
 223        if (diag)
 224                dtab_count = 30;
 225
 226        if (len > 0) {
 227                cp += len;
 228                if (*(buffer+len-1) == '\n')
 229                        cp--;
 230        }
 231
 232        lastchar = cp;
 233        *cp = '\0';
 234        kdb_printf("%s", buffer);
 235poll_again:
 236        key = kdb_read_get_key(buffer, bufsize);
 237        if (key == -1)
 238                return buffer;
 239        if (key != 9)
 240                tab = 0;
 241        switch (key) {
 242        case 8: /* backspace */
 243                if (cp > buffer) {
 244                        if (cp < lastchar) {
 245                                memcpy(tmpbuffer, cp, lastchar - cp);
 246                                memcpy(cp-1, tmpbuffer, lastchar - cp);
 247                        }
 248                        *(--lastchar) = '\0';
 249                        --cp;
 250                        kdb_printf("\b%s \r", cp);
 251                        tmp = *cp;
 252                        *cp = '\0';
 253                        kdb_printf(kdb_prompt_str);
 254                        kdb_printf("%s", buffer);
 255                        *cp = tmp;
 256                }
 257                break;
 258        case 13: /* enter */
 259                *lastchar++ = '\n';
 260                *lastchar++ = '\0';
 261                if (!KDB_STATE(KGDB_TRANS)) {
 262                        KDB_STATE_SET(KGDB_TRANS);
 263                        kdb_printf("%s", buffer);
 264                }
 265                kdb_printf("\n");
 266                return buffer;
 267        case 4: /* Del */
 268                if (cp < lastchar) {
 269                        memcpy(tmpbuffer, cp+1, lastchar - cp - 1);
 270                        memcpy(cp, tmpbuffer, lastchar - cp - 1);
 271                        *(--lastchar) = '\0';
 272                        kdb_printf("%s \r", cp);
 273                        tmp = *cp;
 274                        *cp = '\0';
 275                        kdb_printf(kdb_prompt_str);
 276                        kdb_printf("%s", buffer);
 277                        *cp = tmp;
 278                }
 279                break;
 280        case 1: /* Home */
 281                if (cp > buffer) {
 282                        kdb_printf("\r");
 283                        kdb_printf(kdb_prompt_str);
 284                        cp = buffer;
 285                }
 286                break;
 287        case 5: /* End */
 288                if (cp < lastchar) {
 289                        kdb_printf("%s", cp);
 290                        cp = lastchar;
 291                }
 292                break;
 293        case 2: /* Left */
 294                if (cp > buffer) {
 295                        kdb_printf("\b");
 296                        --cp;
 297                }
 298                break;
 299        case 14: /* Down */
 300                memset(tmpbuffer, ' ',
 301                       strlen(kdb_prompt_str) + (lastchar-buffer));
 302                *(tmpbuffer+strlen(kdb_prompt_str) +
 303                  (lastchar-buffer)) = '\0';
 304                kdb_printf("\r%s\r", tmpbuffer);
 305                *lastchar = (char)key;
 306                *(lastchar+1) = '\0';
 307                return lastchar;
 308        case 6: /* Right */
 309                if (cp < lastchar) {
 310                        kdb_printf("%c", *cp);
 311                        ++cp;
 312                }
 313                break;
 314        case 16: /* Up */
 315                memset(tmpbuffer, ' ',
 316                       strlen(kdb_prompt_str) + (lastchar-buffer));
 317                *(tmpbuffer+strlen(kdb_prompt_str) +
 318                  (lastchar-buffer)) = '\0';
 319                kdb_printf("\r%s\r", tmpbuffer);
 320                *lastchar = (char)key;
 321                *(lastchar+1) = '\0';
 322                return lastchar;
 323        case 9: /* Tab */
 324                if (tab < 2)
 325                        ++tab;
 326                p_tmp = buffer;
 327                while (*p_tmp == ' ')
 328                        p_tmp++;
 329                if (p_tmp > cp)
 330                        break;
 331                memcpy(tmpbuffer, p_tmp, cp-p_tmp);
 332                *(tmpbuffer + (cp-p_tmp)) = '\0';
 333                p_tmp = strrchr(tmpbuffer, ' ');
 334                if (p_tmp)
 335                        ++p_tmp;
 336                else
 337                        p_tmp = tmpbuffer;
 338                len = strlen(p_tmp);
 339                buf_size = sizeof(tmpbuffer) - (p_tmp - tmpbuffer);
 340                count = kallsyms_symbol_complete(p_tmp, buf_size);
 341                if (tab == 2 && count > 0) {
 342                        kdb_printf("\n%d symbols are found.", count);
 343                        if (count > dtab_count) {
 344                                count = dtab_count;
 345                                kdb_printf(" But only first %d symbols will"
 346                                           " be printed.\nYou can change the"
 347                                           " environment variable DTABCOUNT.",
 348                                           count);
 349                        }
 350                        kdb_printf("\n");
 351                        for (i = 0; i < count; i++) {
 352                                ret = kallsyms_symbol_next(p_tmp, i, buf_size);
 353                                if (WARN_ON(!ret))
 354                                        break;
 355                                if (ret != -E2BIG)
 356                                        kdb_printf("%s ", p_tmp);
 357                                else
 358                                        kdb_printf("%s... ", p_tmp);
 359                                *(p_tmp + len) = '\0';
 360                        }
 361                        if (i >= dtab_count)
 362                                kdb_printf("...");
 363                        kdb_printf("\n");
 364                        kdb_printf(kdb_prompt_str);
 365                        kdb_printf("%s", buffer);
 366                } else if (tab != 2 && count > 0) {
 367                        len_tmp = strlen(p_tmp);
 368                        strncpy(p_tmp+len_tmp, cp, lastchar-cp+1);
 369                        len_tmp = strlen(p_tmp);
 370                        strncpy(cp, p_tmp+len, len_tmp-len + 1);
 371                        len = len_tmp - len;
 372                        kdb_printf("%s", cp);
 373                        cp += len;
 374                        lastchar += len;
 375                }
 376                kdb_nextline = 1; /* reset output line number */
 377                break;
 378        default:
 379                if (key >= 32 && lastchar < bufend) {
 380                        if (cp < lastchar) {
 381                                memcpy(tmpbuffer, cp, lastchar - cp);
 382                                memcpy(cp+1, tmpbuffer, lastchar - cp);
 383                                *++lastchar = '\0';
 384                                *cp = key;
 385                                kdb_printf("%s\r", cp);
 386                                ++cp;
 387                                tmp = *cp;
 388                                *cp = '\0';
 389                                kdb_printf(kdb_prompt_str);
 390                                kdb_printf("%s", buffer);
 391                                *cp = tmp;
 392                        } else {
 393                                *++lastchar = '\0';
 394                                *cp++ = key;
 395                                /* The kgdb transition check will hide
 396                                 * printed characters if we think that
 397                                 * kgdb is connecting, until the check
 398                                 * fails */
 399                                if (!KDB_STATE(KGDB_TRANS)) {
 400                                        if (kgdb_transition_check(buffer))
 401                                                return buffer;
 402                                } else {
 403                                        kdb_printf("%c", key);
 404                                }
 405                        }
 406                        /* Special escape to kgdb */
 407                        if (lastchar - buffer >= 5 &&
 408                            strcmp(lastchar - 5, "$?#3f") == 0) {
 409                                kdb_gdb_state_pass(lastchar - 5);
 410                                strcpy(buffer, "kgdb");
 411                                KDB_STATE_SET(DOING_KGDB);
 412                                return buffer;
 413                        }
 414                        if (lastchar - buffer >= 11 &&
 415                            strcmp(lastchar - 11, "$qSupported") == 0) {
 416                                kdb_gdb_state_pass(lastchar - 11);
 417                                strcpy(buffer, "kgdb");
 418                                KDB_STATE_SET(DOING_KGDB);
 419                                return buffer;
 420                        }
 421                }
 422                break;
 423        }
 424        goto poll_again;
 425}
 426
 427/*
 428 * kdb_getstr
 429 *
 430 *      Print the prompt string and read a command from the
 431 *      input device.
 432 *
 433 * Parameters:
 434 *      buffer  Address of buffer to receive command
 435 *      bufsize Size of buffer in bytes
 436 *      prompt  Pointer to string to use as prompt string
 437 * Returns:
 438 *      Pointer to command buffer.
 439 * Locking:
 440 *      None.
 441 * Remarks:
 442 *      For SMP kernels, the processor number will be
 443 *      substituted for %d, %x or %o in the prompt.
 444 */
 445
 446char *kdb_getstr(char *buffer, size_t bufsize, const char *prompt)
 447{
 448        if (prompt && kdb_prompt_str != prompt)
 449                strscpy(kdb_prompt_str, prompt, CMD_BUFLEN);
 450        kdb_printf(kdb_prompt_str);
 451        kdb_nextline = 1;       /* Prompt and input resets line number */
 452        return kdb_read(buffer, bufsize);
 453}
 454
 455/*
 456 * kdb_input_flush
 457 *
 458 *      Get rid of any buffered console input.
 459 *
 460 * Parameters:
 461 *      none
 462 * Returns:
 463 *      nothing
 464 * Locking:
 465 *      none
 466 * Remarks:
 467 *      Call this function whenever you want to flush input.  If there is any
 468 *      outstanding input, it ignores all characters until there has been no
 469 *      data for approximately 1ms.
 470 */
 471
 472static void kdb_input_flush(void)
 473{
 474        get_char_func *f;
 475        int res;
 476        int flush_delay = 1;
 477        while (flush_delay) {
 478                flush_delay--;
 479empty:
 480                touch_nmi_watchdog();
 481                for (f = &kdb_poll_funcs[0]; *f; ++f) {
 482                        res = (*f)();
 483                        if (res != -1) {
 484                                flush_delay = 1;
 485                                goto empty;
 486                        }
 487                }
 488                if (flush_delay)
 489                        mdelay(1);
 490        }
 491}
 492
 493/*
 494 * kdb_printf
 495 *
 496 *      Print a string to the output device(s).
 497 *
 498 * Parameters:
 499 *      printf-like format and optional args.
 500 * Returns:
 501 *      0
 502 * Locking:
 503 *      None.
 504 * Remarks:
 505 *      use 'kdbcons->write()' to avoid polluting 'log_buf' with
 506 *      kdb output.
 507 *
 508 *  If the user is doing a cmd args | grep srch
 509 *  then kdb_grepping_flag is set.
 510 *  In that case we need to accumulate full lines (ending in \n) before
 511 *  searching for the pattern.
 512 */
 513
 514static char kdb_buffer[256];    /* A bit too big to go on stack */
 515static char *next_avail = kdb_buffer;
 516static int  size_avail;
 517static int  suspend_grep;
 518
 519/*
 520 * search arg1 to see if it contains arg2
 521 * (kdmain.c provides flags for ^pat and pat$)
 522 *
 523 * return 1 for found, 0 for not found
 524 */
 525static int kdb_search_string(char *searched, char *searchfor)
 526{
 527        char firstchar, *cp;
 528        int len1, len2;
 529
 530        /* not counting the newline at the end of "searched" */
 531        len1 = strlen(searched)-1;
 532        len2 = strlen(searchfor);
 533        if (len1 < len2)
 534                return 0;
 535        if (kdb_grep_leading && kdb_grep_trailing && len1 != len2)
 536                return 0;
 537        if (kdb_grep_leading) {
 538                if (!strncmp(searched, searchfor, len2))
 539                        return 1;
 540        } else if (kdb_grep_trailing) {
 541                if (!strncmp(searched+len1-len2, searchfor, len2))
 542                        return 1;
 543        } else {
 544                firstchar = *searchfor;
 545                cp = searched;
 546                while ((cp = strchr(cp, firstchar))) {
 547                        if (!strncmp(cp, searchfor, len2))
 548                                return 1;
 549                        cp++;
 550                }
 551        }
 552        return 0;
 553}
 554
 555int vkdb_printf(enum kdb_msgsrc src, const char *fmt, va_list ap)
 556{
 557        int diag;
 558        int linecount;
 559        int colcount;
 560        int logging, saved_loglevel = 0;
 561        int retlen = 0;
 562        int fnd, len;
 563        int this_cpu, old_cpu;
 564        char *cp, *cp2, *cphold = NULL, replaced_byte = ' ';
 565        char *moreprompt = "more> ";
 566        struct console *c = console_drivers;
 567        unsigned long uninitialized_var(flags);
 568
 569        /* Serialize kdb_printf if multiple cpus try to write at once.
 570         * But if any cpu goes recursive in kdb, just print the output,
 571         * even if it is interleaved with any other text.
 572         */
 573        local_irq_save(flags);
 574        this_cpu = smp_processor_id();
 575        for (;;) {
 576                old_cpu = cmpxchg(&kdb_printf_cpu, -1, this_cpu);
 577                if (old_cpu == -1 || old_cpu == this_cpu)
 578                        break;
 579
 580                cpu_relax();
 581        }
 582
 583        diag = kdbgetintenv("LINES", &linecount);
 584        if (diag || linecount <= 1)
 585                linecount = 24;
 586
 587        diag = kdbgetintenv("COLUMNS", &colcount);
 588        if (diag || colcount <= 1)
 589                colcount = 80;
 590
 591        diag = kdbgetintenv("LOGGING", &logging);
 592        if (diag)
 593                logging = 0;
 594
 595        if (!kdb_grepping_flag || suspend_grep) {
 596                /* normally, every vsnprintf starts a new buffer */
 597                next_avail = kdb_buffer;
 598                size_avail = sizeof(kdb_buffer);
 599        }
 600        vsnprintf(next_avail, size_avail, fmt, ap);
 601
 602        /*
 603         * If kdb_parse() found that the command was cmd xxx | grep yyy
 604         * then kdb_grepping_flag is set, and kdb_grep_string contains yyy
 605         *
 606         * Accumulate the print data up to a newline before searching it.
 607         * (vsnprintf does null-terminate the string that it generates)
 608         */
 609
 610        /* skip the search if prints are temporarily unconditional */
 611        if (!suspend_grep && kdb_grepping_flag) {
 612                cp = strchr(kdb_buffer, '\n');
 613                if (!cp) {
 614                        /*
 615                         * Special cases that don't end with newlines
 616                         * but should be written without one:
 617                         *   The "[nn]kdb> " prompt should
 618                         *   appear at the front of the buffer.
 619                         *
 620                         *   The "[nn]more " prompt should also be
 621                         *     (MOREPROMPT -> moreprompt)
 622                         *   written *   but we print that ourselves,
 623                         *   we set the suspend_grep flag to make
 624                         *   it unconditional.
 625                         *
 626                         */
 627                        if (next_avail == kdb_buffer) {
 628                                /*
 629                                 * these should occur after a newline,
 630                                 * so they will be at the front of the
 631                                 * buffer
 632                                 */
 633                                cp2 = kdb_buffer;
 634                                len = strlen(kdb_prompt_str);
 635                                if (!strncmp(cp2, kdb_prompt_str, len)) {
 636                                        /*
 637                                         * We're about to start a new
 638                                         * command, so we can go back
 639                                         * to normal mode.
 640                                         */
 641                                        kdb_grepping_flag = 0;
 642                                        goto kdb_printit;
 643                                }
 644                        }
 645                        /* no newline; don't search/write the buffer
 646                           until one is there */
 647                        len = strlen(kdb_buffer);
 648                        next_avail = kdb_buffer + len;
 649                        size_avail = sizeof(kdb_buffer) - len;
 650                        goto kdb_print_out;
 651                }
 652
 653                /*
 654                 * The newline is present; print through it or discard
 655                 * it, depending on the results of the search.
 656                 */
 657                cp++;                /* to byte after the newline */
 658                replaced_byte = *cp; /* remember what/where it was */
 659                cphold = cp;
 660                *cp = '\0';          /* end the string for our search */
 661
 662                /*
 663                 * We now have a newline at the end of the string
 664                 * Only continue with this output if it contains the
 665                 * search string.
 666                 */
 667                fnd = kdb_search_string(kdb_buffer, kdb_grep_string);
 668                if (!fnd) {
 669                        /*
 670                         * At this point the complete line at the start
 671                         * of kdb_buffer can be discarded, as it does
 672                         * not contain what the user is looking for.
 673                         * Shift the buffer left.
 674                         */
 675                        *cphold = replaced_byte;
 676                        strcpy(kdb_buffer, cphold);
 677                        len = strlen(kdb_buffer);
 678                        next_avail = kdb_buffer + len;
 679                        size_avail = sizeof(kdb_buffer) - len;
 680                        goto kdb_print_out;
 681                }
 682                if (kdb_grepping_flag >= KDB_GREPPING_FLAG_SEARCH)
 683                        /*
 684                         * This was a interactive search (using '/' at more
 685                         * prompt) and it has completed. Clear the flag.
 686                         */
 687                        kdb_grepping_flag = 0;
 688                /*
 689                 * at this point the string is a full line and
 690                 * should be printed, up to the null.
 691                 */
 692        }
 693kdb_printit:
 694
 695        /*
 696         * Write to all consoles.
 697         */
 698        retlen = strlen(kdb_buffer);
 699        cp = (char *) printk_skip_headers(kdb_buffer);
 700        if (!dbg_kdb_mode && kgdb_connected) {
 701                gdbstub_msg_write(cp, retlen - (cp - kdb_buffer));
 702        } else {
 703                if (dbg_io_ops && !dbg_io_ops->is_console) {
 704                        len = retlen - (cp - kdb_buffer);
 705                        cp2 = cp;
 706                        while (len--) {
 707                                dbg_io_ops->write_char(*cp2);
 708                                cp2++;
 709                        }
 710                }
 711                while (c) {
 712                        c->write(c, cp, retlen - (cp - kdb_buffer));
 713                        touch_nmi_watchdog();
 714                        c = c->next;
 715                }
 716        }
 717        if (logging) {
 718                saved_loglevel = console_loglevel;
 719                console_loglevel = CONSOLE_LOGLEVEL_SILENT;
 720                if (printk_get_level(kdb_buffer) || src == KDB_MSGSRC_PRINTK)
 721                        printk("%s", kdb_buffer);
 722                else
 723                        pr_info("%s", kdb_buffer);
 724        }
 725
 726        if (KDB_STATE(PAGER)) {
 727                /*
 728                 * Check printed string to decide how to bump the
 729                 * kdb_nextline to control when the more prompt should
 730                 * show up.
 731                 */
 732                int got = 0;
 733                len = retlen;
 734                while (len--) {
 735                        if (kdb_buffer[len] == '\n') {
 736                                kdb_nextline++;
 737                                got = 0;
 738                        } else if (kdb_buffer[len] == '\r') {
 739                                got = 0;
 740                        } else {
 741                                got++;
 742                        }
 743                }
 744                kdb_nextline += got / (colcount + 1);
 745        }
 746
 747        /* check for having reached the LINES number of printed lines */
 748        if (kdb_nextline >= linecount) {
 749                char buf1[16] = "";
 750
 751                /* Watch out for recursion here.  Any routine that calls
 752                 * kdb_printf will come back through here.  And kdb_read
 753                 * uses kdb_printf to echo on serial consoles ...
 754                 */
 755                kdb_nextline = 1;       /* In case of recursion */
 756
 757                /*
 758                 * Pause until cr.
 759                 */
 760                moreprompt = kdbgetenv("MOREPROMPT");
 761                if (moreprompt == NULL)
 762                        moreprompt = "more> ";
 763
 764                kdb_input_flush();
 765                c = console_drivers;
 766
 767                if (dbg_io_ops && !dbg_io_ops->is_console) {
 768                        len = strlen(moreprompt);
 769                        cp = moreprompt;
 770                        while (len--) {
 771                                dbg_io_ops->write_char(*cp);
 772                                cp++;
 773                        }
 774                }
 775                while (c) {
 776                        c->write(c, moreprompt, strlen(moreprompt));
 777                        touch_nmi_watchdog();
 778                        c = c->next;
 779                }
 780
 781                if (logging)
 782                        printk("%s", moreprompt);
 783
 784                kdb_read(buf1, 2); /* '2' indicates to return
 785                                    * immediately after getting one key. */
 786                kdb_nextline = 1;       /* Really set output line 1 */
 787
 788                /* empty and reset the buffer: */
 789                kdb_buffer[0] = '\0';
 790                next_avail = kdb_buffer;
 791                size_avail = sizeof(kdb_buffer);
 792                if ((buf1[0] == 'q') || (buf1[0] == 'Q')) {
 793                        /* user hit q or Q */
 794                        KDB_FLAG_SET(CMD_INTERRUPT); /* command interrupted */
 795                        KDB_STATE_CLEAR(PAGER);
 796                        /* end of command output; back to normal mode */
 797                        kdb_grepping_flag = 0;
 798                        kdb_printf("\n");
 799                } else if (buf1[0] == ' ') {
 800                        kdb_printf("\r");
 801                        suspend_grep = 1; /* for this recursion */
 802                } else if (buf1[0] == '\n') {
 803                        kdb_nextline = linecount - 1;
 804                        kdb_printf("\r");
 805                        suspend_grep = 1; /* for this recursion */
 806                } else if (buf1[0] == '/' && !kdb_grepping_flag) {
 807                        kdb_printf("\r");
 808                        kdb_getstr(kdb_grep_string, KDB_GREP_STRLEN,
 809                                   kdbgetenv("SEARCHPROMPT") ?: "search> ");
 810                        *strchrnul(kdb_grep_string, '\n') = '\0';
 811                        kdb_grepping_flag += KDB_GREPPING_FLAG_SEARCH;
 812                        suspend_grep = 1; /* for this recursion */
 813                } else if (buf1[0] && buf1[0] != '\n') {
 814                        /* user hit something other than enter */
 815                        suspend_grep = 1; /* for this recursion */
 816                        if (buf1[0] != '/')
 817                                kdb_printf(
 818                                    "\nOnly 'q', 'Q' or '/' are processed at "
 819                                    "more prompt, input ignored\n");
 820                        else
 821                                kdb_printf("\n'/' cannot be used during | "
 822                                           "grep filtering, input ignored\n");
 823                } else if (kdb_grepping_flag) {
 824                        /* user hit enter */
 825                        suspend_grep = 1; /* for this recursion */
 826                        kdb_printf("\n");
 827                }
 828                kdb_input_flush();
 829        }
 830
 831        /*
 832         * For grep searches, shift the printed string left.
 833         *  replaced_byte contains the character that was overwritten with
 834         *  the terminating null, and cphold points to the null.
 835         * Then adjust the notion of available space in the buffer.
 836         */
 837        if (kdb_grepping_flag && !suspend_grep) {
 838                *cphold = replaced_byte;
 839                strcpy(kdb_buffer, cphold);
 840                len = strlen(kdb_buffer);
 841                next_avail = kdb_buffer + len;
 842                size_avail = sizeof(kdb_buffer) - len;
 843        }
 844
 845kdb_print_out:
 846        suspend_grep = 0; /* end of what may have been a recursive call */
 847        if (logging)
 848                console_loglevel = saved_loglevel;
 849        /* kdb_printf_cpu locked the code above. */
 850        smp_store_release(&kdb_printf_cpu, old_cpu);
 851        local_irq_restore(flags);
 852        return retlen;
 853}
 854
 855int kdb_printf(const char *fmt, ...)
 856{
 857        va_list ap;
 858        int r;
 859
 860        va_start(ap, fmt);
 861        r = vkdb_printf(KDB_MSGSRC_INTERNAL, fmt, ap);
 862        va_end(ap);
 863
 864        return r;
 865}
 866EXPORT_SYMBOL_GPL(kdb_printf);
 867