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 30 char kdb_prompt_str[CMD_BUFLEN]; 31 32 int kdb_trap_printk; 33 int kdb_printf_cpu = -1; 34 35 static 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 52 static 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 204 static 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); 235 poll_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 446 char *kdb_getstr(char *buffer, size_t bufsize, const char *prompt) 447 { 448 if (prompt && kdb_prompt_str != prompt) 449 strncpy(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 472 static 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--; 479 empty: 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 514 static char kdb_buffer[256]; /* A bit too big to go on stack */ 515 static char *next_avail = kdb_buffer; 516 static int size_avail; 517 static 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 */ 525 static 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 555 int 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 } 693 kdb_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 845 kdb_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 855 int 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 } 866 EXPORT_SYMBOL_GPL(kdb_printf); 867