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