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; 33 34static 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 45static 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 197static 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); 228poll_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 428char *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 454static 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--; 461empty: 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 496static char kdb_buffer[256]; /* A bit too big to go on stack */ 497static char *next_avail = kdb_buffer; 498static int size_avail; 499static 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 */ 507static 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 537int 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 /* skip the search if prints are temporarily unconditional */ 586 if (!suspend_grep && kdb_grepping_flag) { 587 cp = strchr(kdb_buffer, '\n'); 588 if (!cp) { 589 /* 590 * Special cases that don't end with newlines 591 * but should be written without one: 592 * The "[nn]kdb> " prompt should 593 * appear at the front of the buffer. 594 * 595 * The "[nn]more " prompt should also be 596 * (MOREPROMPT -> moreprompt) 597 * written * but we print that ourselves, 598 * we set the suspend_grep flag to make 599 * it unconditional. 600 * 601 */ 602 if (next_avail == kdb_buffer) { 603 /* 604 * these should occur after a newline, 605 * so they will be at the front of the 606 * buffer 607 */ 608 cp2 = kdb_buffer; 609 len = strlen(kdb_prompt_str); 610 if (!strncmp(cp2, kdb_prompt_str, len)) { 611 /* 612 * We're about to start a new 613 * command, so we can go back 614 * to normal mode. 615 */ 616 kdb_grepping_flag = 0; 617 goto kdb_printit; 618 } 619 } 620 /* no newline; don't search/write the buffer 621 until one is there */ 622 len = strlen(kdb_buffer); 623 next_avail = kdb_buffer + len; 624 size_avail = sizeof(kdb_buffer) - len; 625 goto kdb_print_out; 626 } 627 628 /* 629 * The newline is present; print through it or discard 630 * it, depending on the results of the search. 631 */ 632 cp++; /* to byte after the newline */ 633 replaced_byte = *cp; /* remember what/where it was */ 634 cphold = cp; 635 *cp = '\0'; /* end the string for our search */ 636 637 /* 638 * We now have a newline at the end of the string 639 * Only continue with this output if it contains the 640 * search string. 641 */ 642 fnd = kdb_search_string(kdb_buffer, kdb_grep_string); 643 if (!fnd) { 644 /* 645 * At this point the complete line at the start 646 * of kdb_buffer can be discarded, as it does 647 * not contain what the user is looking for. 648 * Shift the buffer left. 649 */ 650 *cphold = replaced_byte; 651 strcpy(kdb_buffer, cphold); 652 len = strlen(kdb_buffer); 653 next_avail = kdb_buffer + len; 654 size_avail = sizeof(kdb_buffer) - len; 655 goto kdb_print_out; 656 } 657 /* 658 * at this point the string is a full line and 659 * should be printed, up to the null. 660 */ 661 } 662kdb_printit: 663 664 /* 665 * Write to all consoles. 666 */ 667 retlen = strlen(kdb_buffer); 668 if (!dbg_kdb_mode && kgdb_connected) { 669 gdbstub_msg_write(kdb_buffer, retlen); 670 } else { 671 if (!dbg_io_ops->is_console) { 672 len = strlen(kdb_buffer); 673 cp = kdb_buffer; 674 while (len--) { 675 dbg_io_ops->write_char(*cp); 676 cp++; 677 } 678 } 679 while (c) { 680 c->write(c, kdb_buffer, retlen); 681 touch_nmi_watchdog(); 682 c = c->next; 683 } 684 } 685 if (logging) { 686 saved_loglevel = console_loglevel; 687 console_loglevel = 0; 688 printk(KERN_INFO "%s", kdb_buffer); 689 } 690 691 if (KDB_STATE(PAGER) && strchr(kdb_buffer, '\n')) 692 kdb_nextline++; 693 694 /* check for having reached the LINES number of printed lines */ 695 if (kdb_nextline == linecount) { 696 char buf1[16] = ""; 697#if defined(CONFIG_SMP) 698 char buf2[32]; 699#endif 700 701 /* Watch out for recursion here. Any routine that calls 702 * kdb_printf will come back through here. And kdb_read 703 * uses kdb_printf to echo on serial consoles ... 704 */ 705 kdb_nextline = 1; /* In case of recursion */ 706 707 /* 708 * Pause until cr. 709 */ 710 moreprompt = kdbgetenv("MOREPROMPT"); 711 if (moreprompt == NULL) 712 moreprompt = "more> "; 713 714#if defined(CONFIG_SMP) 715 if (strchr(moreprompt, '%')) { 716 sprintf(buf2, moreprompt, get_cpu()); 717 put_cpu(); 718 moreprompt = buf2; 719 } 720#endif 721 722 kdb_input_flush(); 723 c = console_drivers; 724 725 if (!dbg_io_ops->is_console) { 726 len = strlen(moreprompt); 727 cp = moreprompt; 728 while (len--) { 729 dbg_io_ops->write_char(*cp); 730 cp++; 731 } 732 } 733 while (c) { 734 c->write(c, moreprompt, strlen(moreprompt)); 735 touch_nmi_watchdog(); 736 c = c->next; 737 } 738 739 if (logging) 740 printk("%s", moreprompt); 741 742 kdb_read(buf1, 2); /* '2' indicates to return 743 * immediately after getting one key. */ 744 kdb_nextline = 1; /* Really set output line 1 */ 745 746 /* empty and reset the buffer: */ 747 kdb_buffer[0] = '\0'; 748 next_avail = kdb_buffer; 749 size_avail = sizeof(kdb_buffer); 750 if ((buf1[0] == 'q') || (buf1[0] == 'Q')) { 751 /* user hit q or Q */ 752 KDB_FLAG_SET(CMD_INTERRUPT); /* command interrupted */ 753 KDB_STATE_CLEAR(PAGER); 754 /* end of command output; back to normal mode */ 755 kdb_grepping_flag = 0; 756 kdb_printf("\n"); 757 } else if (buf1[0] == ' ') { 758 kdb_printf("\n"); 759 suspend_grep = 1; /* for this recursion */ 760 } else if (buf1[0] == '\n') { 761 kdb_nextline = linecount - 1; 762 kdb_printf("\r"); 763 suspend_grep = 1; /* for this recursion */ 764 } else if (buf1[0] && buf1[0] != '\n') { 765 /* user hit something other than enter */ 766 suspend_grep = 1; /* for this recursion */ 767 kdb_printf("\nOnly 'q' or 'Q' are processed at more " 768 "prompt, input ignored\n"); 769 } else if (kdb_grepping_flag) { 770 /* user hit enter */ 771 suspend_grep = 1; /* for this recursion */ 772 kdb_printf("\n"); 773 } 774 kdb_input_flush(); 775 } 776 777 /* 778 * For grep searches, shift the printed string left. 779 * replaced_byte contains the character that was overwritten with 780 * the terminating null, and cphold points to the null. 781 * Then adjust the notion of available space in the buffer. 782 */ 783 if (kdb_grepping_flag && !suspend_grep) { 784 *cphold = replaced_byte; 785 strcpy(kdb_buffer, cphold); 786 len = strlen(kdb_buffer); 787 next_avail = kdb_buffer + len; 788 size_avail = sizeof(kdb_buffer) - len; 789 } 790 791kdb_print_out: 792 suspend_grep = 0; /* end of what may have been a recursive call */ 793 if (logging) 794 console_loglevel = saved_loglevel; 795 if (KDB_STATE(PRINTF_LOCK) && got_printf_lock) { 796 got_printf_lock = 0; 797 spin_unlock_irqrestore(&kdb_printf_lock, flags); 798 KDB_STATE_CLEAR(PRINTF_LOCK); 799 atomic_dec(&kdb_event); 800 } else { 801 __release(kdb_printf_lock); 802 } 803 kdb_trap_printk = saved_trap_printk; 804 preempt_enable(); 805 return retlen; 806} 807 808int kdb_printf(const char *fmt, ...) 809{ 810 va_list ap; 811 int r; 812 813 va_start(ap, fmt); 814 r = vkdb_printf(fmt, ap); 815 va_end(ap); 816 817 return r; 818} 819