Branch data Line data Source code
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 : 0 : static int kgdb_transition_check(char *buffer)
36 : : {
37 : 0 : if (buffer[0] != '+' && buffer[0] != '$') {
38 : 0 : KDB_STATE_SET(KGDB_TRANS);
39 : 0 : kdb_printf("%s", buffer);
40 : : } else {
41 : 0 : int slen = strlen(buffer);
42 : 0 : if (slen > 3 && buffer[slen - 3] == '#') {
43 : 0 : kdb_gdb_state_pass(buffer);
44 : 0 : strcpy(buffer, "kgdb");
45 : 0 : KDB_STATE_SET(DOING_KGDB);
46 : 0 : return 1;
47 : : }
48 : : }
49 : : return 0;
50 : : }
51 : :
52 : 0 : 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 : 0 : for (f = &kdb_poll_funcs[0]; ; ++f) {
63 : 0 : if (*f == NULL) {
64 : : /* Reset NMI watchdog once per poll loop */
65 : : touch_nmi_watchdog();
66 : : f = &kdb_poll_funcs[0];
67 : : }
68 : 0 : if (escape_delay == 2) {
69 : 0 : *ped = '\0';
70 : : ped = escape_data;
71 : 0 : --escape_delay;
72 : : }
73 : 0 : if (escape_delay == 1) {
74 : 0 : key = *ped++;
75 : : if (!*ped)
76 : : --escape_delay;
77 : : break;
78 : : }
79 : 0 : key = (*f)();
80 : 0 : if (key == -1) {
81 : 0 : if (escape_delay) {
82 : 0 : udelay(ESCAPE_UDELAY);
83 : 0 : --escape_delay;
84 : : }
85 : 0 : continue;
86 : : }
87 : 0 : if (bufsize <= 2) {
88 : 0 : if (key == '\r')
89 : : key = '\n';
90 : 0 : *buffer++ = key;
91 : 0 : *buffer = '\0';
92 : 0 : return -1;
93 : : }
94 : 0 : if (escape_delay == 0 && key == '\e') {
95 : : escape_delay = ESCAPE_DELAY;
96 : : ped = escape_data;
97 : : f_escape = f;
98 : : }
99 : 0 : if (escape_delay) {
100 : 0 : *ped++ = key;
101 : 0 : if (f_escape != f) {
102 : : escape_delay = 2;
103 : 0 : continue;
104 : : }
105 : 0 : if (ped - escape_data == 1) {
106 : : /* \e */
107 : 0 : continue;
108 : 0 : } else if (ped - escape_data == 2) {
109 : : /* \e<something> */
110 : 0 : if (key != '[')
111 : : escape_delay = 2;
112 : 0 : continue;
113 : 0 : } else if (ped - escape_data == 3) {
114 : : /* \e[<something> */
115 : : int mapkey = 0;
116 : 0 : 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 : 0 : if (mapkey != -1) {
137 : 0 : if (mapkey > 0) {
138 : 0 : escape_data[0] = mapkey;
139 : 0 : escape_data[1] = '\0';
140 : : }
141 : : escape_delay = 2;
142 : : }
143 : 0 : continue;
144 : 0 : } else if (ped - escape_data == 4) {
145 : : /* \e[<1,3,4><something> */
146 : : int mapkey = 0;
147 : 0 : if (key == '~') {
148 : 0 : 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 : 0 : if (mapkey > 0) {
161 : 0 : escape_data[0] = mapkey;
162 : 0 : escape_data[1] = '\0';
163 : : }
164 : : escape_delay = 2;
165 : 0 : continue;
166 : : }
167 : : }
168 : : break; /* A key to process */
169 : 0 : }
170 : 0 : 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 : 0 : static char *kdb_read(char *buffer, size_t bufsize)
205 : : {
206 : : char *cp = buffer;
207 : 0 : 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 : 0 : 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 : 0 : diag = kdbgetintenv("DTABCOUNT", &dtab_count);
223 : 0 : if (diag)
224 : 0 : dtab_count = 30;
225 : :
226 : 0 : if (len > 0) {
227 : 0 : cp += len;
228 : 0 : if (*(buffer+len-1) == '\n')
229 : 0 : cp--;
230 : : }
231 : :
232 : : lastchar = cp;
233 : 0 : *cp = '\0';
234 : 0 : kdb_printf("%s", buffer);
235 : : poll_again:
236 : 0 : key = kdb_read_get_key(buffer, bufsize);
237 : 0 : if (key == -1)
238 : : return buffer;
239 : 0 : if (key != 9)
240 : : tab = 0;
241 : 0 : switch (key) {
242 : : case 8: /* backspace */
243 : 0 : if (cp > buffer) {
244 : 0 : if (cp < lastchar) {
245 : 0 : memcpy(tmpbuffer, cp, lastchar - cp);
246 : 0 : memcpy(cp-1, tmpbuffer, lastchar - cp);
247 : : }
248 : 0 : *(--lastchar) = '\0';
249 : 0 : --cp;
250 : 0 : kdb_printf("\b%s \r", cp);
251 : 0 : tmp = *cp;
252 : 0 : *cp = '\0';
253 : 0 : kdb_printf(kdb_prompt_str);
254 : 0 : kdb_printf("%s", buffer);
255 : 0 : *cp = tmp;
256 : : }
257 : : break;
258 : : case 13: /* enter */
259 : 0 : *lastchar++ = '\n';
260 : 0 : *lastchar++ = '\0';
261 : 0 : if (!KDB_STATE(KGDB_TRANS)) {
262 : 0 : KDB_STATE_SET(KGDB_TRANS);
263 : 0 : kdb_printf("%s", buffer);
264 : : }
265 : 0 : kdb_printf("\n");
266 : 0 : return buffer;
267 : : case 4: /* Del */
268 : 0 : if (cp < lastchar) {
269 : 0 : memcpy(tmpbuffer, cp+1, lastchar - cp - 1);
270 : 0 : memcpy(cp, tmpbuffer, lastchar - cp - 1);
271 : 0 : *(--lastchar) = '\0';
272 : 0 : kdb_printf("%s \r", cp);
273 : 0 : tmp = *cp;
274 : 0 : *cp = '\0';
275 : 0 : kdb_printf(kdb_prompt_str);
276 : 0 : kdb_printf("%s", buffer);
277 : 0 : *cp = tmp;
278 : : }
279 : : break;
280 : : case 1: /* Home */
281 : 0 : if (cp > buffer) {
282 : 0 : kdb_printf("\r");
283 : 0 : kdb_printf(kdb_prompt_str);
284 : : cp = buffer;
285 : : }
286 : : break;
287 : : case 5: /* End */
288 : 0 : if (cp < lastchar) {
289 : 0 : kdb_printf("%s", cp);
290 : : cp = lastchar;
291 : : }
292 : : break;
293 : : case 2: /* Left */
294 : 0 : if (cp > buffer) {
295 : 0 : kdb_printf("\b");
296 : 0 : --cp;
297 : : }
298 : : break;
299 : : case 14: /* Down */
300 : 0 : memset(tmpbuffer, ' ',
301 : 0 : strlen(kdb_prompt_str) + (lastchar-buffer));
302 : 0 : *(tmpbuffer+strlen(kdb_prompt_str) +
303 : 0 : (lastchar-buffer)) = '\0';
304 : 0 : kdb_printf("\r%s\r", tmpbuffer);
305 : 0 : *lastchar = (char)key;
306 : 0 : *(lastchar+1) = '\0';
307 : 0 : return lastchar;
308 : : case 6: /* Right */
309 : 0 : if (cp < lastchar) {
310 : 0 : kdb_printf("%c", *cp);
311 : 0 : ++cp;
312 : : }
313 : : break;
314 : : case 16: /* Up */
315 : 0 : memset(tmpbuffer, ' ',
316 : 0 : strlen(kdb_prompt_str) + (lastchar-buffer));
317 : 0 : *(tmpbuffer+strlen(kdb_prompt_str) +
318 : 0 : (lastchar-buffer)) = '\0';
319 : 0 : kdb_printf("\r%s\r", tmpbuffer);
320 : 0 : *lastchar = (char)key;
321 : 0 : *(lastchar+1) = '\0';
322 : 0 : return lastchar;
323 : : case 9: /* Tab */
324 : 0 : if (tab < 2)
325 : 0 : ++tab;
326 : : p_tmp = buffer;
327 : 0 : while (*p_tmp == ' ')
328 : 0 : p_tmp++;
329 : 0 : if (p_tmp > cp)
330 : : break;
331 : 0 : memcpy(tmpbuffer, p_tmp, cp-p_tmp);
332 : 0 : *(tmpbuffer + (cp-p_tmp)) = '\0';
333 : 0 : p_tmp = strrchr(tmpbuffer, ' ');
334 : 0 : if (p_tmp)
335 : 0 : ++p_tmp;
336 : : else
337 : : p_tmp = tmpbuffer;
338 : 0 : len = strlen(p_tmp);
339 : 0 : buf_size = sizeof(tmpbuffer) - (p_tmp - tmpbuffer);
340 : 0 : count = kallsyms_symbol_complete(p_tmp, buf_size);
341 : 0 : if (tab == 2 && count > 0) {
342 : 0 : kdb_printf("\n%d symbols are found.", count);
343 : 0 : if (count > dtab_count) {
344 : : count = dtab_count;
345 : 0 : kdb_printf(" But only first %d symbols will"
346 : : " be printed.\nYou can change the"
347 : : " environment variable DTABCOUNT.",
348 : : count);
349 : : }
350 : 0 : kdb_printf("\n");
351 : 0 : for (i = 0; i < count; i++) {
352 : 0 : ret = kallsyms_symbol_next(p_tmp, i, buf_size);
353 : 0 : if (WARN_ON(!ret))
354 : : break;
355 : 0 : if (ret != -E2BIG)
356 : 0 : kdb_printf("%s ", p_tmp);
357 : : else
358 : 0 : kdb_printf("%s... ", p_tmp);
359 : 0 : *(p_tmp + len) = '\0';
360 : : }
361 : 0 : if (i >= dtab_count)
362 : 0 : kdb_printf("...");
363 : 0 : kdb_printf("\n");
364 : 0 : kdb_printf(kdb_prompt_str);
365 : 0 : kdb_printf("%s", buffer);
366 : 0 : } else if (tab != 2 && count > 0) {
367 : 0 : len_tmp = strlen(p_tmp);
368 : 0 : strncpy(p_tmp+len_tmp, cp, lastchar-cp+1);
369 : 0 : len_tmp = strlen(p_tmp);
370 : 0 : strncpy(cp, p_tmp+len, len_tmp-len + 1);
371 : : len = len_tmp - len;
372 : 0 : kdb_printf("%s", cp);
373 : 0 : cp += len;
374 : 0 : lastchar += len;
375 : : }
376 : 0 : kdb_nextline = 1; /* reset output line number */
377 : 0 : break;
378 : : default:
379 : 0 : if (key >= 32 && lastchar < bufend) {
380 : 0 : if (cp < lastchar) {
381 : 0 : memcpy(tmpbuffer, cp, lastchar - cp);
382 : 0 : memcpy(cp+1, tmpbuffer, lastchar - cp);
383 : 0 : *++lastchar = '\0';
384 : 0 : *cp = key;
385 : 0 : kdb_printf("%s\r", cp);
386 : : ++cp;
387 : 0 : tmp = *cp;
388 : 0 : *cp = '\0';
389 : 0 : kdb_printf(kdb_prompt_str);
390 : 0 : kdb_printf("%s", buffer);
391 : 0 : *cp = tmp;
392 : : } else {
393 : 0 : *++lastchar = '\0';
394 : 0 : *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 : 0 : if (!KDB_STATE(KGDB_TRANS)) {
400 : 0 : if (kgdb_transition_check(buffer))
401 : : return buffer;
402 : : } else {
403 : 0 : kdb_printf("%c", key);
404 : : }
405 : : }
406 : : /* Special escape to kgdb */
407 : 0 : if (lastchar - buffer >= 5 &&
408 : 0 : strcmp(lastchar - 5, "$?#3f") == 0) {
409 : 0 : kdb_gdb_state_pass(lastchar - 5);
410 : 0 : strcpy(buffer, "kgdb");
411 : 0 : KDB_STATE_SET(DOING_KGDB);
412 : 0 : return buffer;
413 : : }
414 : 0 : if (lastchar - buffer >= 11 &&
415 : 0 : strcmp(lastchar - 11, "$qSupported") == 0) {
416 : 0 : kdb_gdb_state_pass(lastchar - 11);
417 : 0 : strcpy(buffer, "kgdb");
418 : 0 : KDB_STATE_SET(DOING_KGDB);
419 : 0 : 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 : 0 : char *kdb_getstr(char *buffer, size_t bufsize, const char *prompt)
447 : : {
448 : 0 : if (prompt && kdb_prompt_str != prompt)
449 : 0 : strscpy(kdb_prompt_str, prompt, CMD_BUFLEN);
450 : 0 : kdb_printf(kdb_prompt_str);
451 : 0 : kdb_nextline = 1; /* Prompt and input resets line number */
452 : 0 : 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 : 0 : static void kdb_input_flush(void)
473 : : {
474 : : get_char_func *f;
475 : : int res;
476 : : int flush_delay = 1;
477 : 0 : while (flush_delay) {
478 : 0 : flush_delay--;
479 : : empty:
480 : : touch_nmi_watchdog();
481 : 0 : for (f = &kdb_poll_funcs[0]; *f; ++f) {
482 : 0 : res = (*f)();
483 : 0 : if (res != -1) {
484 : : flush_delay = 1;
485 : : goto empty;
486 : : }
487 : : }
488 : 0 : if (flush_delay)
489 : 0 : mdelay(1);
490 : : }
491 : 0 : }
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 : 0 : 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 : 0 : len1 = strlen(searched)-1;
532 : 0 : len2 = strlen(searchfor);
533 : 0 : if (len1 < len2)
534 : : return 0;
535 : 0 : if (kdb_grep_leading && kdb_grep_trailing && len1 != len2)
536 : : return 0;
537 : 0 : if (kdb_grep_leading) {
538 : 0 : if (!strncmp(searched, searchfor, len2))
539 : : return 1;
540 : 0 : } else if (kdb_grep_trailing) {
541 : 0 : if (!strncmp(searched+len1-len2, searchfor, len2))
542 : : return 1;
543 : : } else {
544 : 0 : firstchar = *searchfor;
545 : : cp = searched;
546 : 0 : while ((cp = strchr(cp, firstchar))) {
547 : 0 : if (!strncmp(cp, searchfor, len2))
548 : : return 1;
549 : 0 : cp++;
550 : : }
551 : : }
552 : 0 : return 0;
553 : : }
554 : :
555 : 0 : 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 : 0 : 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 : 0 : local_irq_save(flags);
574 : 0 : this_cpu = smp_processor_id();
575 : : for (;;) {
576 : 0 : old_cpu = cmpxchg(&kdb_printf_cpu, -1, this_cpu);
577 : 0 : if (old_cpu == -1 || old_cpu == this_cpu)
578 : : break;
579 : :
580 : 0 : cpu_relax();
581 : 0 : }
582 : :
583 : 0 : diag = kdbgetintenv("LINES", &linecount);
584 : 0 : if (diag || linecount <= 1)
585 : 0 : linecount = 24;
586 : :
587 : 0 : diag = kdbgetintenv("COLUMNS", &colcount);
588 : 0 : if (diag || colcount <= 1)
589 : 0 : colcount = 80;
590 : :
591 : 0 : diag = kdbgetintenv("LOGGING", &logging);
592 : 0 : if (diag)
593 : 0 : logging = 0;
594 : :
595 : 0 : if (!kdb_grepping_flag || suspend_grep) {
596 : : /* normally, every vsnprintf starts a new buffer */
597 : 0 : next_avail = kdb_buffer;
598 : 0 : size_avail = sizeof(kdb_buffer);
599 : : }
600 : 0 : 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 : 0 : if (!suspend_grep && kdb_grepping_flag) {
612 : 0 : cp = strchr(kdb_buffer, '\n');
613 : 0 : 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 : 0 : 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 : 0 : len = strlen(kdb_prompt_str);
635 : 0 : 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 : 0 : kdb_grepping_flag = 0;
642 : 0 : goto kdb_printit;
643 : : }
644 : : }
645 : : /* no newline; don't search/write the buffer
646 : : until one is there */
647 : 0 : len = strlen(kdb_buffer);
648 : 0 : next_avail = kdb_buffer + len;
649 : 0 : size_avail = sizeof(kdb_buffer) - len;
650 : 0 : 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 : 0 : cp++; /* to byte after the newline */
658 : 0 : replaced_byte = *cp; /* remember what/where it was */
659 : : cphold = cp;
660 : 0 : *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 : 0 : fnd = kdb_search_string(kdb_buffer, kdb_grep_string);
668 : 0 : 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 : 0 : *cphold = replaced_byte;
676 : 0 : strcpy(kdb_buffer, cphold);
677 : 0 : len = strlen(kdb_buffer);
678 : 0 : next_avail = kdb_buffer + len;
679 : 0 : size_avail = sizeof(kdb_buffer) - len;
680 : 0 : goto kdb_print_out;
681 : : }
682 : 0 : 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 : 0 : 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 : 0 : retlen = strlen(kdb_buffer);
699 : 0 : cp = (char *) printk_skip_headers(kdb_buffer);
700 : 0 : if (!dbg_kdb_mode && kgdb_connected) {
701 : 0 : gdbstub_msg_write(cp, retlen - (cp - kdb_buffer));
702 : : } else {
703 : 0 : if (dbg_io_ops && !dbg_io_ops->is_console) {
704 : 0 : len = retlen - (cp - kdb_buffer);
705 : : cp2 = cp;
706 : 0 : while (len--) {
707 : 0 : dbg_io_ops->write_char(*cp2);
708 : 0 : cp2++;
709 : : }
710 : : }
711 : 0 : while (c) {
712 : 0 : c->write(c, cp, retlen - (cp - kdb_buffer));
713 : : touch_nmi_watchdog();
714 : 0 : c = c->next;
715 : : }
716 : : }
717 : 0 : if (logging) {
718 : 0 : saved_loglevel = console_loglevel;
719 : 0 : console_loglevel = CONSOLE_LOGLEVEL_SILENT;
720 : 0 : if (printk_get_level(kdb_buffer) || src == KDB_MSGSRC_PRINTK)
721 : 0 : printk("%s", kdb_buffer);
722 : : else
723 : 0 : pr_info("%s", kdb_buffer);
724 : : }
725 : :
726 : 0 : 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 : 0 : while (len--) {
735 : 0 : if (kdb_buffer[len] == '\n') {
736 : 0 : kdb_nextline++;
737 : : got = 0;
738 : 0 : } else if (kdb_buffer[len] == '\r') {
739 : : got = 0;
740 : : } else {
741 : 0 : got++;
742 : : }
743 : : }
744 : 0 : kdb_nextline += got / (colcount + 1);
745 : : }
746 : :
747 : : /* check for having reached the LINES number of printed lines */
748 : 0 : if (kdb_nextline >= linecount) {
749 : 0 : 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 : 0 : kdb_nextline = 1; /* In case of recursion */
756 : :
757 : : /*
758 : : * Pause until cr.
759 : : */
760 : 0 : moreprompt = kdbgetenv("MOREPROMPT");
761 : 0 : if (moreprompt == NULL)
762 : : moreprompt = "more> ";
763 : :
764 : 0 : kdb_input_flush();
765 : 0 : c = console_drivers;
766 : :
767 : 0 : if (dbg_io_ops && !dbg_io_ops->is_console) {
768 : 0 : len = strlen(moreprompt);
769 : : cp = moreprompt;
770 : 0 : while (len--) {
771 : 0 : dbg_io_ops->write_char(*cp);
772 : 0 : cp++;
773 : : }
774 : : }
775 : 0 : while (c) {
776 : 0 : c->write(c, moreprompt, strlen(moreprompt));
777 : : touch_nmi_watchdog();
778 : 0 : c = c->next;
779 : : }
780 : :
781 : 0 : if (logging)
782 : 0 : printk("%s", moreprompt);
783 : :
784 : 0 : kdb_read(buf1, 2); /* '2' indicates to return
785 : : * immediately after getting one key. */
786 : 0 : kdb_nextline = 1; /* Really set output line 1 */
787 : :
788 : : /* empty and reset the buffer: */
789 : 0 : kdb_buffer[0] = '\0';
790 : 0 : next_avail = kdb_buffer;
791 : 0 : size_avail = sizeof(kdb_buffer);
792 : 0 : if ((buf1[0] == 'q') || (buf1[0] == 'Q')) {
793 : : /* user hit q or Q */
794 : 0 : KDB_FLAG_SET(CMD_INTERRUPT); /* command interrupted */
795 : 0 : KDB_STATE_CLEAR(PAGER);
796 : : /* end of command output; back to normal mode */
797 : 0 : kdb_grepping_flag = 0;
798 : 0 : kdb_printf("\n");
799 : 0 : } else if (buf1[0] == ' ') {
800 : 0 : kdb_printf("\r");
801 : 0 : suspend_grep = 1; /* for this recursion */
802 : 0 : } else if (buf1[0] == '\n') {
803 : 0 : kdb_nextline = linecount - 1;
804 : 0 : kdb_printf("\r");
805 : 0 : suspend_grep = 1; /* for this recursion */
806 : 0 : } else if (buf1[0] == '/' && !kdb_grepping_flag) {
807 : 0 : kdb_printf("\r");
808 : 0 : kdb_getstr(kdb_grep_string, KDB_GREP_STRLEN,
809 : 0 : kdbgetenv("SEARCHPROMPT") ?: "search> ");
810 : 0 : *strchrnul(kdb_grep_string, '\n') = '\0';
811 : 0 : kdb_grepping_flag += KDB_GREPPING_FLAG_SEARCH;
812 : 0 : suspend_grep = 1; /* for this recursion */
813 : 0 : } else if (buf1[0] && buf1[0] != '\n') {
814 : : /* user hit something other than enter */
815 : 0 : suspend_grep = 1; /* for this recursion */
816 : 0 : if (buf1[0] != '/')
817 : 0 : kdb_printf(
818 : : "\nOnly 'q', 'Q' or '/' are processed at "
819 : : "more prompt, input ignored\n");
820 : : else
821 : 0 : kdb_printf("\n'/' cannot be used during | "
822 : : "grep filtering, input ignored\n");
823 : 0 : } else if (kdb_grepping_flag) {
824 : : /* user hit enter */
825 : 0 : suspend_grep = 1; /* for this recursion */
826 : 0 : kdb_printf("\n");
827 : : }
828 : 0 : 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 : 0 : if (kdb_grepping_flag && !suspend_grep) {
838 : 0 : *cphold = replaced_byte;
839 : 0 : strcpy(kdb_buffer, cphold);
840 : 0 : len = strlen(kdb_buffer);
841 : 0 : next_avail = kdb_buffer + len;
842 : 0 : size_avail = sizeof(kdb_buffer) - len;
843 : : }
844 : :
845 : : kdb_print_out:
846 : 0 : suspend_grep = 0; /* end of what may have been a recursive call */
847 : 0 : if (logging)
848 : 0 : console_loglevel = saved_loglevel;
849 : : /* kdb_printf_cpu locked the code above. */
850 : 0 : smp_store_release(&kdb_printf_cpu, old_cpu);
851 : 0 : local_irq_restore(flags);
852 : 0 : return retlen;
853 : : }
854 : :
855 : 0 : int kdb_printf(const char *fmt, ...)
856 : : {
857 : : va_list ap;
858 : : int r;
859 : :
860 : 0 : va_start(ap, fmt);
861 : 0 : r = vkdb_printf(KDB_MSGSRC_INTERNAL, fmt, ap);
862 : 0 : va_end(ap);
863 : :
864 : 0 : return r;
865 : : }
866 : : EXPORT_SYMBOL_GPL(kdb_printf);
|
