~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/debug/kdb/kdb_io.c

Version: ~ [ linux-5.6-rc3 ] ~ [ linux-5.5.6 ] ~ [ linux-5.4.22 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.106 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.171 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.214 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.214 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp