1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/ctype.h>
15#include <linux/string.h>
16#include <linux/kernel.h>
17#include <linux/kmsg_dump.h>
18#include <linux/reboot.h>
19#include <linux/sched.h>
20#include <linux/sysrq.h>
21#include <linux/smp.h>
22#include <linux/utsname.h>
23#include <linux/vmalloc.h>
24#include <linux/atomic.h>
25#include <linux/module.h>
26#include <linux/mm.h>
27#include <linux/init.h>
28#include <linux/kallsyms.h>
29#include <linux/kgdb.h>
30#include <linux/kdb.h>
31#include <linux/notifier.h>
32#include <linux/interrupt.h>
33#include <linux/delay.h>
34#include <linux/nmi.h>
35#include <linux/time.h>
36#include <linux/ptrace.h>
37#include <linux/sysctl.h>
38#include <linux/cpu.h>
39#include <linux/kdebug.h>
40#include <linux/proc_fs.h>
41#include <linux/uaccess.h>
42#include <linux/slab.h>
43#include "kdb_private.h"
44
45#define GREP_LEN 256
46char kdb_grep_string[GREP_LEN];
47int kdb_grepping_flag;
48EXPORT_SYMBOL(kdb_grepping_flag);
49int kdb_grep_leading;
50int kdb_grep_trailing;
51
52
53
54
55int kdb_flags;
56atomic_t kdb_event;
57
58
59
60
61
62int kdb_initial_cpu = -1;
63int kdb_nextline = 1;
64int kdb_state;
65
66struct task_struct *kdb_current_task;
67EXPORT_SYMBOL(kdb_current_task);
68struct pt_regs *kdb_current_regs;
69
70const char *kdb_diemsg;
71static int kdb_go_count;
72#ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC
73static unsigned int kdb_continue_catastrophic =
74 CONFIG_KDB_CONTINUE_CATASTROPHIC;
75#else
76static unsigned int kdb_continue_catastrophic;
77#endif
78
79
80static kdbtab_t *kdb_commands;
81#define KDB_BASE_CMD_MAX 50
82static int kdb_max_commands = KDB_BASE_CMD_MAX;
83static kdbtab_t kdb_base_commands[KDB_BASE_CMD_MAX];
84#define for_each_kdbcmd(cmd, num) \
85 for ((cmd) = kdb_base_commands, (num) = 0; \
86 num < kdb_max_commands; \
87 num++, num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++)
88
89typedef struct _kdbmsg {
90 int km_diag;
91 char *km_msg;
92} kdbmsg_t;
93
94#define KDBMSG(msgnum, text) \
95 { KDB_##msgnum, text }
96
97static kdbmsg_t kdbmsgs[] = {
98 KDBMSG(NOTFOUND, "Command Not Found"),
99 KDBMSG(ARGCOUNT, "Improper argument count, see usage."),
100 KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
101 "8 is only allowed on 64 bit systems"),
102 KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"),
103 KDBMSG(NOTENV, "Cannot find environment variable"),
104 KDBMSG(NOENVVALUE, "Environment variable should have value"),
105 KDBMSG(NOTIMP, "Command not implemented"),
106 KDBMSG(ENVFULL, "Environment full"),
107 KDBMSG(ENVBUFFULL, "Environment buffer full"),
108 KDBMSG(TOOMANYBPT, "Too many breakpoints defined"),
109#ifdef CONFIG_CPU_XSCALE
110 KDBMSG(TOOMANYDBREGS, "More breakpoints than ibcr registers defined"),
111#else
112 KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"),
113#endif
114 KDBMSG(DUPBPT, "Duplicate breakpoint address"),
115 KDBMSG(BPTNOTFOUND, "Breakpoint not found"),
116 KDBMSG(BADMODE, "Invalid IDMODE"),
117 KDBMSG(BADINT, "Illegal numeric value"),
118 KDBMSG(INVADDRFMT, "Invalid symbolic address format"),
119 KDBMSG(BADREG, "Invalid register name"),
120 KDBMSG(BADCPUNUM, "Invalid cpu number"),
121 KDBMSG(BADLENGTH, "Invalid length field"),
122 KDBMSG(NOBP, "No Breakpoint exists"),
123 KDBMSG(BADADDR, "Invalid address"),
124};
125#undef KDBMSG
126
127static const int __nkdb_err = ARRAY_SIZE(kdbmsgs);
128
129
130
131
132
133
134
135
136
137
138
139
140static char *__env[] = {
141#if defined(CONFIG_SMP)
142 "PROMPT=[%d]kdb> ",
143#else
144 "PROMPT=kdb> ",
145#endif
146 "MOREPROMPT=more> ",
147 "RADIX=16",
148 "MDCOUNT=8",
149 KDB_PLATFORM_ENV,
150 "DTABCOUNT=30",
151 "NOSECT=1",
152 (char *)0,
153 (char *)0,
154 (char *)0,
155 (char *)0,
156 (char *)0,
157 (char *)0,
158 (char *)0,
159 (char *)0,
160 (char *)0,
161 (char *)0,
162 (char *)0,
163 (char *)0,
164 (char *)0,
165 (char *)0,
166 (char *)0,
167 (char *)0,
168 (char *)0,
169 (char *)0,
170 (char *)0,
171 (char *)0,
172 (char *)0,
173 (char *)0,
174 (char *)0,
175 (char *)0,
176};
177
178static const int __nenv = ARRAY_SIZE(__env);
179
180struct task_struct *kdb_curr_task(int cpu)
181{
182 struct task_struct *p = curr_task(cpu);
183#ifdef _TIF_MCA_INIT
184 if ((task_thread_info(p)->flags & _TIF_MCA_INIT) && KDB_TSK(cpu))
185 p = krp->p;
186#endif
187 return p;
188}
189
190
191
192
193
194
195
196
197
198
199char *kdbgetenv(const char *match)
200{
201 char **ep = __env;
202 int matchlen = strlen(match);
203 int i;
204
205 for (i = 0; i < __nenv; i++) {
206 char *e = *ep++;
207
208 if (!e)
209 continue;
210
211 if ((strncmp(match, e, matchlen) == 0)
212 && ((e[matchlen] == '\0')
213 || (e[matchlen] == '='))) {
214 char *cp = strchr(e, '=');
215 return cp ? ++cp : "";
216 }
217 }
218 return NULL;
219}
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237static char *kdballocenv(size_t bytes)
238{
239#define KDB_ENVBUFSIZE 512
240 static char envbuffer[KDB_ENVBUFSIZE];
241 static int envbufsize;
242 char *ep = NULL;
243
244 if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) {
245 ep = &envbuffer[envbufsize];
246 envbufsize += bytes;
247 }
248 return ep;
249}
250
251
252
253
254
255
256
257
258
259
260
261static int kdbgetulenv(const char *match, unsigned long *value)
262{
263 char *ep;
264
265 ep = kdbgetenv(match);
266 if (!ep)
267 return KDB_NOTENV;
268 if (strlen(ep) == 0)
269 return KDB_NOENVVALUE;
270
271 *value = simple_strtoul(ep, NULL, 0);
272
273 return 0;
274}
275
276
277
278
279
280
281
282
283
284
285
286int kdbgetintenv(const char *match, int *value)
287{
288 unsigned long val;
289 int diag;
290
291 diag = kdbgetulenv(match, &val);
292 if (!diag)
293 *value = (int) val;
294 return diag;
295}
296
297
298
299
300
301
302
303
304
305
306
307int kdbgetularg(const char *arg, unsigned long *value)
308{
309 char *endp;
310 unsigned long val;
311
312 val = simple_strtoul(arg, &endp, 0);
313
314 if (endp == arg) {
315
316
317
318
319 val = simple_strtoul(arg, &endp, 16);
320 if (endp == arg)
321 return KDB_BADINT;
322 }
323
324 *value = val;
325
326 return 0;
327}
328
329int kdbgetu64arg(const char *arg, u64 *value)
330{
331 char *endp;
332 u64 val;
333
334 val = simple_strtoull(arg, &endp, 0);
335
336 if (endp == arg) {
337
338 val = simple_strtoull(arg, &endp, 16);
339 if (endp == arg)
340 return KDB_BADINT;
341 }
342
343 *value = val;
344
345 return 0;
346}
347
348
349
350
351
352int kdb_set(int argc, const char **argv)
353{
354 int i;
355 char *ep;
356 size_t varlen, vallen;
357
358
359
360
361
362
363
364 if (argc == 3) {
365 argv[2] = argv[3];
366 argc--;
367 }
368
369 if (argc != 2)
370 return KDB_ARGCOUNT;
371
372
373
374
375 if (strcmp(argv[1], "KDBDEBUG") == 0) {
376 unsigned int debugflags;
377 char *cp;
378
379 debugflags = simple_strtoul(argv[2], &cp, 0);
380 if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) {
381 kdb_printf("kdb: illegal debug flags '%s'\n",
382 argv[2]);
383 return 0;
384 }
385 kdb_flags = (kdb_flags &
386 ~(KDB_DEBUG_FLAG_MASK << KDB_DEBUG_FLAG_SHIFT))
387 | (debugflags << KDB_DEBUG_FLAG_SHIFT);
388
389 return 0;
390 }
391
392
393
394
395
396 varlen = strlen(argv[1]);
397 vallen = strlen(argv[2]);
398 ep = kdballocenv(varlen + vallen + 2);
399 if (ep == (char *)0)
400 return KDB_ENVBUFFULL;
401
402 sprintf(ep, "%s=%s", argv[1], argv[2]);
403
404 ep[varlen+vallen+1] = '\0';
405
406 for (i = 0; i < __nenv; i++) {
407 if (__env[i]
408 && ((strncmp(__env[i], argv[1], varlen) == 0)
409 && ((__env[i][varlen] == '\0')
410 || (__env[i][varlen] == '=')))) {
411 __env[i] = ep;
412 return 0;
413 }
414 }
415
416
417
418
419 for (i = 0; i < __nenv-1; i++) {
420 if (__env[i] == (char *)0) {
421 __env[i] = ep;
422 return 0;
423 }
424 }
425
426 return KDB_ENVFULL;
427}
428
429static int kdb_check_regs(void)
430{
431 if (!kdb_current_regs) {
432 kdb_printf("No current kdb registers."
433 " You may need to select another task\n");
434 return KDB_BADREG;
435 }
436 return 0;
437}
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
465 unsigned long *value, long *offset,
466 char **name)
467{
468 unsigned long addr;
469 unsigned long off = 0;
470 int positive;
471 int diag;
472 int found = 0;
473 char *symname;
474 char symbol = '\0';
475 char *cp;
476 kdb_symtab_t symtab;
477
478
479
480
481
482
483
484
485
486 if (*nextarg > argc)
487 return KDB_ARGCOUNT;
488
489 symname = (char *)argv[*nextarg];
490
491
492
493
494
495
496
497 cp = strpbrk(symname, "+-");
498 if (cp != NULL) {
499 symbol = *cp;
500 *cp++ = '\0';
501 }
502
503 if (symname[0] == '$') {
504 diag = kdbgetulenv(&symname[1], &addr);
505 if (diag)
506 return diag;
507 } else if (symname[0] == '%') {
508 diag = kdb_check_regs();
509 if (diag)
510 return diag;
511
512
513
514 return KDB_NOTIMP;
515 } else {
516 found = kdbgetsymval(symname, &symtab);
517 if (found) {
518 addr = symtab.sym_start;
519 } else {
520 diag = kdbgetularg(argv[*nextarg], &addr);
521 if (diag)
522 return diag;
523 }
524 }
525
526 if (!found)
527 found = kdbnearsym(addr, &symtab);
528
529 (*nextarg)++;
530
531 if (name)
532 *name = symname;
533 if (value)
534 *value = addr;
535 if (offset && name && *name)
536 *offset = addr - symtab.sym_start;
537
538 if ((*nextarg > argc)
539 && (symbol == '\0'))
540 return 0;
541
542
543
544
545
546 if (symbol == '\0') {
547 if ((argv[*nextarg][0] != '+')
548 && (argv[*nextarg][0] != '-')) {
549
550
551
552 return 0;
553 } else {
554 positive = (argv[*nextarg][0] == '+');
555 (*nextarg)++;
556 }
557 } else
558 positive = (symbol == '+');
559
560
561
562
563 if ((*nextarg > argc)
564 && (symbol == '\0')) {
565 return KDB_INVADDRFMT;
566 }
567
568 if (!symbol) {
569 cp = (char *)argv[*nextarg];
570 (*nextarg)++;
571 }
572
573 diag = kdbgetularg(cp, &off);
574 if (diag)
575 return diag;
576
577 if (!positive)
578 off = -off;
579
580 if (offset)
581 *offset += off;
582
583 if (value)
584 *value += off;
585
586 return 0;
587}
588
589static void kdb_cmderror(int diag)
590{
591 int i;
592
593 if (diag >= 0) {
594 kdb_printf("no error detected (diagnostic is %d)\n", diag);
595 return;
596 }
597
598 for (i = 0; i < __nkdb_err; i++) {
599 if (kdbmsgs[i].km_diag == diag) {
600 kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg);
601 return;
602 }
603 }
604
605 kdb_printf("Unknown diag %d\n", -diag);
606}
607
608
609
610
611
612
613
614
615
616
617
618
619
620struct defcmd_set {
621 int count;
622 int usable;
623 char *name;
624 char *usage;
625 char *help;
626 char **command;
627};
628static struct defcmd_set *defcmd_set;
629static int defcmd_set_count;
630static int defcmd_in_progress;
631
632
633static int kdb_exec_defcmd(int argc, const char **argv);
634
635static int kdb_defcmd2(const char *cmdstr, const char *argv0)
636{
637 struct defcmd_set *s = defcmd_set + defcmd_set_count - 1;
638 char **save_command = s->command;
639 if (strcmp(argv0, "endefcmd") == 0) {
640 defcmd_in_progress = 0;
641 if (!s->count)
642 s->usable = 0;
643 if (s->usable)
644 kdb_register(s->name, kdb_exec_defcmd,
645 s->usage, s->help, 0);
646 return 0;
647 }
648 if (!s->usable)
649 return KDB_NOTIMP;
650 s->command = kzalloc((s->count + 1) * sizeof(*(s->command)), GFP_KDB);
651 if (!s->command) {
652 kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
653 cmdstr);
654 s->usable = 0;
655 return KDB_NOTIMP;
656 }
657 memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
658 s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB);
659 kfree(save_command);
660 return 0;
661}
662
663static int kdb_defcmd(int argc, const char **argv)
664{
665 struct defcmd_set *save_defcmd_set = defcmd_set, *s;
666 if (defcmd_in_progress) {
667 kdb_printf("kdb: nested defcmd detected, assuming missing "
668 "endefcmd\n");
669 kdb_defcmd2("endefcmd", "endefcmd");
670 }
671 if (argc == 0) {
672 int i;
673 for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) {
674 kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name,
675 s->usage, s->help);
676 for (i = 0; i < s->count; ++i)
677 kdb_printf("%s", s->command[i]);
678 kdb_printf("endefcmd\n");
679 }
680 return 0;
681 }
682 if (argc != 3)
683 return KDB_ARGCOUNT;
684 if (in_dbg_master()) {
685 kdb_printf("Command only available during kdb_init()\n");
686 return KDB_NOTIMP;
687 }
688 defcmd_set = kmalloc((defcmd_set_count + 1) * sizeof(*defcmd_set),
689 GFP_KDB);
690 if (!defcmd_set)
691 goto fail_defcmd;
692 memcpy(defcmd_set, save_defcmd_set,
693 defcmd_set_count * sizeof(*defcmd_set));
694 s = defcmd_set + defcmd_set_count;
695 memset(s, 0, sizeof(*s));
696 s->usable = 1;
697 s->name = kdb_strdup(argv[1], GFP_KDB);
698 if (!s->name)
699 goto fail_name;
700 s->usage = kdb_strdup(argv[2], GFP_KDB);
701 if (!s->usage)
702 goto fail_usage;
703 s->help = kdb_strdup(argv[3], GFP_KDB);
704 if (!s->help)
705 goto fail_help;
706 if (s->usage[0] == '"') {
707 strcpy(s->usage, argv[2]+1);
708 s->usage[strlen(s->usage)-1] = '\0';
709 }
710 if (s->help[0] == '"') {
711 strcpy(s->help, argv[3]+1);
712 s->help[strlen(s->help)-1] = '\0';
713 }
714 ++defcmd_set_count;
715 defcmd_in_progress = 1;
716 kfree(save_defcmd_set);
717 return 0;
718fail_help:
719 kfree(s->usage);
720fail_usage:
721 kfree(s->name);
722fail_name:
723 kfree(defcmd_set);
724fail_defcmd:
725 kdb_printf("Could not allocate new defcmd_set entry for %s\n", argv[1]);
726 defcmd_set = save_defcmd_set;
727 return KDB_NOTIMP;
728}
729
730
731
732
733
734
735
736
737
738
739static int kdb_exec_defcmd(int argc, const char **argv)
740{
741 int i, ret;
742 struct defcmd_set *s;
743 if (argc != 0)
744 return KDB_ARGCOUNT;
745 for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
746 if (strcmp(s->name, argv[0]) == 0)
747 break;
748 }
749 if (i == defcmd_set_count) {
750 kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
751 argv[0]);
752 return KDB_NOTIMP;
753 }
754 for (i = 0; i < s->count; ++i) {
755
756
757 argv = NULL;
758 kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
759 ret = kdb_parse(s->command[i]);
760 if (ret)
761 return ret;
762 }
763 return 0;
764}
765
766
767#define KDB_CMD_HISTORY_COUNT 32
768#define CMD_BUFLEN 200
769
770static unsigned int cmd_head, cmd_tail;
771static unsigned int cmdptr;
772static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
773static char cmd_cur[CMD_BUFLEN];
774
775
776
777
778static void parse_grep(const char *str)
779{
780 int len;
781 char *cp = (char *)str, *cp2;
782
783
784 if (*cp != '|')
785 return;
786 cp++;
787 while (isspace(*cp))
788 cp++;
789 if (strncmp(cp, "grep ", 5)) {
790 kdb_printf("invalid 'pipe', see grephelp\n");
791 return;
792 }
793 cp += 5;
794 while (isspace(*cp))
795 cp++;
796 cp2 = strchr(cp, '\n');
797 if (cp2)
798 *cp2 = '\0';
799 len = strlen(cp);
800 if (len == 0) {
801 kdb_printf("invalid 'pipe', see grephelp\n");
802 return;
803 }
804
805 if (*cp == '"') {
806
807
808 cp++;
809 cp2 = strchr(cp, '"');
810 if (!cp2) {
811 kdb_printf("invalid quoted string, see grephelp\n");
812 return;
813 }
814 *cp2 = '\0';
815 }
816 kdb_grep_leading = 0;
817 if (*cp == '^') {
818 kdb_grep_leading = 1;
819 cp++;
820 }
821 len = strlen(cp);
822 kdb_grep_trailing = 0;
823 if (*(cp+len-1) == '$') {
824 kdb_grep_trailing = 1;
825 *(cp+len-1) = '\0';
826 }
827 len = strlen(cp);
828 if (!len)
829 return;
830 if (len >= GREP_LEN) {
831 kdb_printf("search string too long\n");
832 return;
833 }
834 strcpy(kdb_grep_string, cp);
835 kdb_grepping_flag++;
836 return;
837}
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865#define MAXARGC 20
866
867int kdb_parse(const char *cmdstr)
868{
869 static char *argv[MAXARGC];
870 static int argc;
871 static char cbuf[CMD_BUFLEN+2];
872 char *cp;
873 char *cpp, quoted;
874 kdbtab_t *tp;
875 int i, escaped, ignore_errors = 0, check_grep;
876
877
878
879
880 cp = (char *)cmdstr;
881 kdb_grepping_flag = check_grep = 0;
882
883 if (KDB_FLAG(CMD_INTERRUPT)) {
884
885
886 KDB_FLAG_CLEAR(CMD_INTERRUPT);
887 KDB_STATE_SET(PAGER);
888 argc = 0;
889 }
890
891 if (*cp != '\n' && *cp != '\0') {
892 argc = 0;
893 cpp = cbuf;
894 while (*cp) {
895
896 while (isspace(*cp))
897 cp++;
898 if ((*cp == '\0') || (*cp == '\n') ||
899 (*cp == '#' && !defcmd_in_progress))
900 break;
901
902 if (*cp == '|') {
903 check_grep++;
904 break;
905 }
906 if (cpp >= cbuf + CMD_BUFLEN) {
907 kdb_printf("kdb_parse: command buffer "
908 "overflow, command ignored\n%s\n",
909 cmdstr);
910 return KDB_NOTFOUND;
911 }
912 if (argc >= MAXARGC - 1) {
913 kdb_printf("kdb_parse: too many arguments, "
914 "command ignored\n%s\n", cmdstr);
915 return KDB_NOTFOUND;
916 }
917 argv[argc++] = cpp;
918 escaped = 0;
919 quoted = '\0';
920
921
922 while (*cp && *cp != '\n' &&
923 (escaped || quoted || !isspace(*cp))) {
924 if (cpp >= cbuf + CMD_BUFLEN)
925 break;
926 if (escaped) {
927 escaped = 0;
928 *cpp++ = *cp++;
929 continue;
930 }
931 if (*cp == '\\') {
932 escaped = 1;
933 ++cp;
934 continue;
935 }
936 if (*cp == quoted)
937 quoted = '\0';
938 else if (*cp == '\'' || *cp == '"')
939 quoted = *cp;
940 *cpp = *cp++;
941 if (*cpp == '=' && !quoted)
942 break;
943 ++cpp;
944 }
945 *cpp++ = '\0';
946 }
947 }
948 if (!argc)
949 return 0;
950 if (check_grep)
951 parse_grep(cp);
952 if (defcmd_in_progress) {
953 int result = kdb_defcmd2(cmdstr, argv[0]);
954 if (!defcmd_in_progress) {
955 argc = 0;
956 *(argv[0]) = '\0';
957 }
958 return result;
959 }
960 if (argv[0][0] == '-' && argv[0][1] &&
961 (argv[0][1] < '0' || argv[0][1] > '9')) {
962 ignore_errors = 1;
963 ++argv[0];
964 }
965
966 for_each_kdbcmd(tp, i) {
967 if (tp->cmd_name) {
968
969
970
971
972
973 if (tp->cmd_minlen
974 && (strlen(argv[0]) <= tp->cmd_minlen)) {
975 if (strncmp(argv[0],
976 tp->cmd_name,
977 tp->cmd_minlen) == 0) {
978 break;
979 }
980 }
981
982 if (strcmp(argv[0], tp->cmd_name) == 0)
983 break;
984 }
985 }
986
987
988
989
990
991
992 if (i == kdb_max_commands) {
993 for_each_kdbcmd(tp, i) {
994 if (tp->cmd_name) {
995 if (strncmp(argv[0],
996 tp->cmd_name,
997 strlen(tp->cmd_name)) == 0) {
998 break;
999 }
1000 }
1001 }
1002 }
1003
1004 if (i < kdb_max_commands) {
1005 int result;
1006 KDB_STATE_SET(CMD);
1007 result = (*tp->cmd_func)(argc-1, (const char **)argv);
1008 if (result && ignore_errors && result > KDB_CMD_GO)
1009 result = 0;
1010 KDB_STATE_CLEAR(CMD);
1011 switch (tp->cmd_repeat) {
1012 case KDB_REPEAT_NONE:
1013 argc = 0;
1014 if (argv[0])
1015 *(argv[0]) = '\0';
1016 break;
1017 case KDB_REPEAT_NO_ARGS:
1018 argc = 1;
1019 if (argv[1])
1020 *(argv[1]) = '\0';
1021 break;
1022 case KDB_REPEAT_WITH_ARGS:
1023 break;
1024 }
1025 return result;
1026 }
1027
1028
1029
1030
1031
1032
1033
1034
1035 {
1036 unsigned long value;
1037 char *name = NULL;
1038 long offset;
1039 int nextarg = 0;
1040
1041 if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1042 &value, &offset, &name)) {
1043 return KDB_NOTFOUND;
1044 }
1045
1046 kdb_printf("%s = ", argv[0]);
1047 kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1048 kdb_printf("\n");
1049 return 0;
1050 }
1051}
1052
1053
1054static int handle_ctrl_cmd(char *cmd)
1055{
1056#define CTRL_P 16
1057#define CTRL_N 14
1058
1059
1060 if (cmd_head == cmd_tail)
1061 return 0;
1062 switch (*cmd) {
1063 case CTRL_P:
1064 if (cmdptr != cmd_tail)
1065 cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT;
1066 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1067 return 1;
1068 case CTRL_N:
1069 if (cmdptr != cmd_head)
1070 cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1071 strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1072 return 1;
1073 }
1074 return 0;
1075}
1076
1077
1078
1079
1080
1081static int kdb_reboot(int argc, const char **argv)
1082{
1083 emergency_restart();
1084 kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1085 while (1)
1086 cpu_relax();
1087
1088 return 0;
1089}
1090
1091static void kdb_dumpregs(struct pt_regs *regs)
1092{
1093 int old_lvl = console_loglevel;
1094 console_loglevel = 15;
1095 kdb_trap_printk++;
1096 show_regs(regs);
1097 kdb_trap_printk--;
1098 kdb_printf("\n");
1099 console_loglevel = old_lvl;
1100}
1101
1102void kdb_set_current_task(struct task_struct *p)
1103{
1104 kdb_current_task = p;
1105
1106 if (kdb_task_has_cpu(p)) {
1107 kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1108 return;
1109 }
1110 kdb_current_regs = NULL;
1111}
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1133 kdb_dbtrap_t db_result)
1134{
1135 char *cmdbuf;
1136 int diag;
1137 struct task_struct *kdb_current =
1138 kdb_curr_task(raw_smp_processor_id());
1139
1140 KDB_DEBUG_STATE("kdb_local 1", reason);
1141 kdb_go_count = 0;
1142 if (reason == KDB_REASON_DEBUG) {
1143
1144 } else {
1145 kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
1146 kdb_current, kdb_current ? kdb_current->pid : 0);
1147#if defined(CONFIG_SMP)
1148 kdb_printf("on processor %d ", raw_smp_processor_id());
1149#endif
1150 }
1151
1152 switch (reason) {
1153 case KDB_REASON_DEBUG:
1154 {
1155
1156
1157
1158
1159 switch (db_result) {
1160 case KDB_DB_BPT:
1161 kdb_printf("\nEntering kdb (0x%p, pid %d) ",
1162 kdb_current, kdb_current->pid);
1163#if defined(CONFIG_SMP)
1164 kdb_printf("on processor %d ", raw_smp_processor_id());
1165#endif
1166 kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1167 instruction_pointer(regs));
1168 break;
1169 case KDB_DB_SS:
1170 break;
1171 case KDB_DB_SSBPT:
1172 KDB_DEBUG_STATE("kdb_local 4", reason);
1173 return 1;
1174 default:
1175 kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1176 db_result);
1177 break;
1178 }
1179
1180 }
1181 break;
1182 case KDB_REASON_ENTER:
1183 if (KDB_STATE(KEYBOARD))
1184 kdb_printf("due to Keyboard Entry\n");
1185 else
1186 kdb_printf("due to KDB_ENTER()\n");
1187 break;
1188 case KDB_REASON_KEYBOARD:
1189 KDB_STATE_SET(KEYBOARD);
1190 kdb_printf("due to Keyboard Entry\n");
1191 break;
1192 case KDB_REASON_ENTER_SLAVE:
1193
1194 case KDB_REASON_SWITCH:
1195 kdb_printf("due to cpu switch\n");
1196 break;
1197 case KDB_REASON_OOPS:
1198 kdb_printf("Oops: %s\n", kdb_diemsg);
1199 kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1200 instruction_pointer(regs));
1201 kdb_dumpregs(regs);
1202 break;
1203 case KDB_REASON_NMI:
1204 kdb_printf("due to NonMaskable Interrupt @ "
1205 kdb_machreg_fmt "\n",
1206 instruction_pointer(regs));
1207 kdb_dumpregs(regs);
1208 break;
1209 case KDB_REASON_SSTEP:
1210 case KDB_REASON_BREAK:
1211 kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1212 reason == KDB_REASON_BREAK ?
1213 "Breakpoint" : "SS trap", instruction_pointer(regs));
1214
1215
1216
1217
1218 if (db_result != KDB_DB_BPT) {
1219 kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1220 db_result);
1221 KDB_DEBUG_STATE("kdb_local 6", reason);
1222 return 0;
1223 }
1224 break;
1225 case KDB_REASON_RECURSE:
1226 kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1227 instruction_pointer(regs));
1228 break;
1229 default:
1230 kdb_printf("kdb: unexpected reason code: %d\n", reason);
1231 KDB_DEBUG_STATE("kdb_local 8", reason);
1232 return 0;
1233 }
1234
1235 while (1) {
1236
1237
1238
1239 kdb_nextline = 1;
1240 KDB_STATE_CLEAR(SUPPRESS);
1241
1242 cmdbuf = cmd_cur;
1243 *cmdbuf = '\0';
1244 *(cmd_hist[cmd_head]) = '\0';
1245
1246do_full_getstr:
1247#if defined(CONFIG_SMP)
1248 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1249 raw_smp_processor_id());
1250#else
1251 snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
1252#endif
1253 if (defcmd_in_progress)
1254 strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1255
1256
1257
1258
1259 cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1260 if (*cmdbuf != '\n') {
1261 if (*cmdbuf < 32) {
1262 if (cmdptr == cmd_head) {
1263 strncpy(cmd_hist[cmd_head], cmd_cur,
1264 CMD_BUFLEN);
1265 *(cmd_hist[cmd_head] +
1266 strlen(cmd_hist[cmd_head])-1) = '\0';
1267 }
1268 if (!handle_ctrl_cmd(cmdbuf))
1269 *(cmd_cur+strlen(cmd_cur)-1) = '\0';
1270 cmdbuf = cmd_cur;
1271 goto do_full_getstr;
1272 } else {
1273 strncpy(cmd_hist[cmd_head], cmd_cur,
1274 CMD_BUFLEN);
1275 }
1276
1277 cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1278 if (cmd_head == cmd_tail)
1279 cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1280 }
1281
1282 cmdptr = cmd_head;
1283 diag = kdb_parse(cmdbuf);
1284 if (diag == KDB_NOTFOUND) {
1285 kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1286 diag = 0;
1287 }
1288 if (diag == KDB_CMD_GO
1289 || diag == KDB_CMD_CPU
1290 || diag == KDB_CMD_SS
1291 || diag == KDB_CMD_KGDB)
1292 break;
1293
1294 if (diag)
1295 kdb_cmderror(diag);
1296 }
1297 KDB_DEBUG_STATE("kdb_local 9", diag);
1298 return diag;
1299}
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309void kdb_print_state(const char *text, int value)
1310{
1311 kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1312 text, raw_smp_processor_id(), value, kdb_initial_cpu,
1313 kdb_state);
1314}
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1342 kdb_dbtrap_t db_result, struct pt_regs *regs)
1343{
1344 int result = 1;
1345
1346 while (1) {
1347
1348
1349
1350
1351 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1352 while (KDB_STATE(HOLD_CPU)) {
1353
1354
1355
1356
1357 if (!KDB_STATE(KDB))
1358 KDB_STATE_SET(KDB);
1359 }
1360
1361 KDB_STATE_CLEAR(SUPPRESS);
1362 KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1363 if (KDB_STATE(LEAVING))
1364 break;
1365
1366 result = kdb_local(reason2, error, regs, db_result);
1367 KDB_DEBUG_STATE("kdb_main_loop 3", result);
1368
1369 if (result == KDB_CMD_CPU)
1370 break;
1371
1372 if (result == KDB_CMD_SS) {
1373 KDB_STATE_SET(DOING_SS);
1374 break;
1375 }
1376
1377 if (result == KDB_CMD_KGDB) {
1378 if (!KDB_STATE(DOING_KGDB))
1379 kdb_printf("Entering please attach debugger "
1380 "or use $D#44+ or $3#33\n");
1381 break;
1382 }
1383 if (result && result != 1 && result != KDB_CMD_GO)
1384 kdb_printf("\nUnexpected kdb_local return code %d\n",
1385 result);
1386 KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1387 break;
1388 }
1389 if (KDB_STATE(DOING_SS))
1390 KDB_STATE_CLEAR(SSBPT);
1391
1392
1393 kdb_kbd_cleanup_state();
1394
1395 return result;
1396}
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408static int kdb_mdr(unsigned long addr, unsigned int count)
1409{
1410 unsigned char c;
1411 while (count--) {
1412 if (kdb_getarea(c, addr))
1413 return 0;
1414 kdb_printf("%02x", c);
1415 addr++;
1416 }
1417 kdb_printf("\n");
1418 return 0;
1419}
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431static void kdb_md_line(const char *fmtstr, unsigned long addr,
1432 int symbolic, int nosect, int bytesperword,
1433 int num, int repeat, int phys)
1434{
1435
1436 kdb_symtab_t symtab;
1437 char cbuf[32];
1438 char *c = cbuf;
1439 int i;
1440 unsigned long word;
1441
1442 memset(cbuf, '\0', sizeof(cbuf));
1443 if (phys)
1444 kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1445 else
1446 kdb_printf(kdb_machreg_fmt0 " ", addr);
1447
1448 for (i = 0; i < num && repeat--; i++) {
1449 if (phys) {
1450 if (kdb_getphysword(&word, addr, bytesperword))
1451 break;
1452 } else if (kdb_getword(&word, addr, bytesperword))
1453 break;
1454 kdb_printf(fmtstr, word);
1455 if (symbolic)
1456 kdbnearsym(word, &symtab);
1457 else
1458 memset(&symtab, 0, sizeof(symtab));
1459 if (symtab.sym_name) {
1460 kdb_symbol_print(word, &symtab, 0);
1461 if (!nosect) {
1462 kdb_printf("\n");
1463 kdb_printf(" %s %s "
1464 kdb_machreg_fmt " "
1465 kdb_machreg_fmt " "
1466 kdb_machreg_fmt, symtab.mod_name,
1467 symtab.sec_name, symtab.sec_start,
1468 symtab.sym_start, symtab.sym_end);
1469 }
1470 addr += bytesperword;
1471 } else {
1472 union {
1473 u64 word;
1474 unsigned char c[8];
1475 } wc;
1476 unsigned char *cp;
1477#ifdef __BIG_ENDIAN
1478 cp = wc.c + 8 - bytesperword;
1479#else
1480 cp = wc.c;
1481#endif
1482 wc.word = word;
1483#define printable_char(c) \
1484 ({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1485 switch (bytesperword) {
1486 case 8:
1487 *c++ = printable_char(*cp++);
1488 *c++ = printable_char(*cp++);
1489 *c++ = printable_char(*cp++);
1490 *c++ = printable_char(*cp++);
1491 addr += 4;
1492 case 4:
1493 *c++ = printable_char(*cp++);
1494 *c++ = printable_char(*cp++);
1495 addr += 2;
1496 case 2:
1497 *c++ = printable_char(*cp++);
1498 addr++;
1499 case 1:
1500 *c++ = printable_char(*cp++);
1501 addr++;
1502 break;
1503 }
1504#undef printable_char
1505 }
1506 }
1507 kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1508 " ", cbuf);
1509}
1510
1511static int kdb_md(int argc, const char **argv)
1512{
1513 static unsigned long last_addr;
1514 static int last_radix, last_bytesperword, last_repeat;
1515 int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1516 int nosect = 0;
1517 char fmtchar, fmtstr[64];
1518 unsigned long addr;
1519 unsigned long word;
1520 long offset = 0;
1521 int symbolic = 0;
1522 int valid = 0;
1523 int phys = 0;
1524
1525 kdbgetintenv("MDCOUNT", &mdcount);
1526 kdbgetintenv("RADIX", &radix);
1527 kdbgetintenv("BYTESPERWORD", &bytesperword);
1528
1529
1530 repeat = mdcount * 16 / bytesperword;
1531
1532 if (strcmp(argv[0], "mdr") == 0) {
1533 if (argc != 2)
1534 return KDB_ARGCOUNT;
1535 valid = 1;
1536 } else if (isdigit(argv[0][2])) {
1537 bytesperword = (int)(argv[0][2] - '0');
1538 if (bytesperword == 0) {
1539 bytesperword = last_bytesperword;
1540 if (bytesperword == 0)
1541 bytesperword = 4;
1542 }
1543 last_bytesperword = bytesperword;
1544 repeat = mdcount * 16 / bytesperword;
1545 if (!argv[0][3])
1546 valid = 1;
1547 else if (argv[0][3] == 'c' && argv[0][4]) {
1548 char *p;
1549 repeat = simple_strtoul(argv[0] + 4, &p, 10);
1550 mdcount = ((repeat * bytesperword) + 15) / 16;
1551 valid = !*p;
1552 }
1553 last_repeat = repeat;
1554 } else if (strcmp(argv[0], "md") == 0)
1555 valid = 1;
1556 else if (strcmp(argv[0], "mds") == 0)
1557 valid = 1;
1558 else if (strcmp(argv[0], "mdp") == 0) {
1559 phys = valid = 1;
1560 }
1561 if (!valid)
1562 return KDB_NOTFOUND;
1563
1564 if (argc == 0) {
1565 if (last_addr == 0)
1566 return KDB_ARGCOUNT;
1567 addr = last_addr;
1568 radix = last_radix;
1569 bytesperword = last_bytesperword;
1570 repeat = last_repeat;
1571 mdcount = ((repeat * bytesperword) + 15) / 16;
1572 }
1573
1574 if (argc) {
1575 unsigned long val;
1576 int diag, nextarg = 1;
1577 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1578 &offset, NULL);
1579 if (diag)
1580 return diag;
1581 if (argc > nextarg+2)
1582 return KDB_ARGCOUNT;
1583
1584 if (argc >= nextarg) {
1585 diag = kdbgetularg(argv[nextarg], &val);
1586 if (!diag) {
1587 mdcount = (int) val;
1588 repeat = mdcount * 16 / bytesperword;
1589 }
1590 }
1591 if (argc >= nextarg+1) {
1592 diag = kdbgetularg(argv[nextarg+1], &val);
1593 if (!diag)
1594 radix = (int) val;
1595 }
1596 }
1597
1598 if (strcmp(argv[0], "mdr") == 0)
1599 return kdb_mdr(addr, mdcount);
1600
1601 switch (radix) {
1602 case 10:
1603 fmtchar = 'd';
1604 break;
1605 case 16:
1606 fmtchar = 'x';
1607 break;
1608 case 8:
1609 fmtchar = 'o';
1610 break;
1611 default:
1612 return KDB_BADRADIX;
1613 }
1614
1615 last_radix = radix;
1616
1617 if (bytesperword > KDB_WORD_SIZE)
1618 return KDB_BADWIDTH;
1619
1620 switch (bytesperword) {
1621 case 8:
1622 sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1623 break;
1624 case 4:
1625 sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1626 break;
1627 case 2:
1628 sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1629 break;
1630 case 1:
1631 sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1632 break;
1633 default:
1634 return KDB_BADWIDTH;
1635 }
1636
1637 last_repeat = repeat;
1638 last_bytesperword = bytesperword;
1639
1640 if (strcmp(argv[0], "mds") == 0) {
1641 symbolic = 1;
1642
1643
1644
1645 bytesperword = KDB_WORD_SIZE;
1646 repeat = mdcount;
1647 kdbgetintenv("NOSECT", &nosect);
1648 }
1649
1650
1651
1652 addr &= ~(bytesperword-1);
1653
1654 while (repeat > 0) {
1655 unsigned long a;
1656 int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1657
1658 if (KDB_FLAG(CMD_INTERRUPT))
1659 return 0;
1660 for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1661 if (phys) {
1662 if (kdb_getphysword(&word, a, bytesperword)
1663 || word)
1664 break;
1665 } else if (kdb_getword(&word, a, bytesperword) || word)
1666 break;
1667 }
1668 n = min(num, repeat);
1669 kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1670 num, repeat, phys);
1671 addr += bytesperword * n;
1672 repeat -= n;
1673 z = (z + num - 1) / num;
1674 if (z > 2) {
1675 int s = num * (z-2);
1676 kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1677 " zero suppressed\n",
1678 addr, addr + bytesperword * s - 1);
1679 addr += bytesperword * s;
1680 repeat -= s;
1681 }
1682 }
1683 last_addr = addr;
1684
1685 return 0;
1686}
1687
1688
1689
1690
1691
1692
1693
1694static int kdb_mm(int argc, const char **argv)
1695{
1696 int diag;
1697 unsigned long addr;
1698 long offset = 0;
1699 unsigned long contents;
1700 int nextarg;
1701 int width;
1702
1703 if (argv[0][2] && !isdigit(argv[0][2]))
1704 return KDB_NOTFOUND;
1705
1706 if (argc < 2)
1707 return KDB_ARGCOUNT;
1708
1709 nextarg = 1;
1710 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1711 if (diag)
1712 return diag;
1713
1714 if (nextarg > argc)
1715 return KDB_ARGCOUNT;
1716 diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1717 if (diag)
1718 return diag;
1719
1720 if (nextarg != argc + 1)
1721 return KDB_ARGCOUNT;
1722
1723 width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1724 diag = kdb_putword(addr, contents, width);
1725 if (diag)
1726 return diag;
1727
1728 kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1729
1730 return 0;
1731}
1732
1733
1734
1735
1736
1737static int kdb_go(int argc, const char **argv)
1738{
1739 unsigned long addr;
1740 int diag;
1741 int nextarg;
1742 long offset;
1743
1744 if (raw_smp_processor_id() != kdb_initial_cpu) {
1745 kdb_printf("go must execute on the entry cpu, "
1746 "please use \"cpu %d\" and then execute go\n",
1747 kdb_initial_cpu);
1748 return KDB_BADCPUNUM;
1749 }
1750 if (argc == 1) {
1751 nextarg = 1;
1752 diag = kdbgetaddrarg(argc, argv, &nextarg,
1753 &addr, &offset, NULL);
1754 if (diag)
1755 return diag;
1756 } else if (argc) {
1757 return KDB_ARGCOUNT;
1758 }
1759
1760 diag = KDB_CMD_GO;
1761 if (KDB_FLAG(CATASTROPHIC)) {
1762 kdb_printf("Catastrophic error detected\n");
1763 kdb_printf("kdb_continue_catastrophic=%d, ",
1764 kdb_continue_catastrophic);
1765 if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1766 kdb_printf("type go a second time if you really want "
1767 "to continue\n");
1768 return 0;
1769 }
1770 if (kdb_continue_catastrophic == 2) {
1771 kdb_printf("forcing reboot\n");
1772 kdb_reboot(0, NULL);
1773 }
1774 kdb_printf("attempting to continue\n");
1775 }
1776 return diag;
1777}
1778
1779
1780
1781
1782static int kdb_rd(int argc, const char **argv)
1783{
1784 int len = kdb_check_regs();
1785#if DBG_MAX_REG_NUM > 0
1786 int i;
1787 char *rname;
1788 int rsize;
1789 u64 reg64;
1790 u32 reg32;
1791 u16 reg16;
1792 u8 reg8;
1793
1794 if (len)
1795 return len;
1796
1797 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1798 rsize = dbg_reg_def[i].size * 2;
1799 if (rsize > 16)
1800 rsize = 2;
1801 if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1802 len = 0;
1803 kdb_printf("\n");
1804 }
1805 if (len)
1806 len += kdb_printf(" ");
1807 switch(dbg_reg_def[i].size * 8) {
1808 case 8:
1809 rname = dbg_get_reg(i, ®8, kdb_current_regs);
1810 if (!rname)
1811 break;
1812 len += kdb_printf("%s: %02x", rname, reg8);
1813 break;
1814 case 16:
1815 rname = dbg_get_reg(i, ®16, kdb_current_regs);
1816 if (!rname)
1817 break;
1818 len += kdb_printf("%s: %04x", rname, reg16);
1819 break;
1820 case 32:
1821 rname = dbg_get_reg(i, ®32, kdb_current_regs);
1822 if (!rname)
1823 break;
1824 len += kdb_printf("%s: %08x", rname, reg32);
1825 break;
1826 case 64:
1827 rname = dbg_get_reg(i, ®64, kdb_current_regs);
1828 if (!rname)
1829 break;
1830 len += kdb_printf("%s: %016llx", rname, reg64);
1831 break;
1832 default:
1833 len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1834 }
1835 }
1836 kdb_printf("\n");
1837#else
1838 if (len)
1839 return len;
1840
1841 kdb_dumpregs(kdb_current_regs);
1842#endif
1843 return 0;
1844}
1845
1846
1847
1848
1849
1850
1851
1852static int kdb_rm(int argc, const char **argv)
1853{
1854#if DBG_MAX_REG_NUM > 0
1855 int diag;
1856 const char *rname;
1857 int i;
1858 u64 reg64;
1859 u32 reg32;
1860 u16 reg16;
1861 u8 reg8;
1862
1863 if (argc != 2)
1864 return KDB_ARGCOUNT;
1865
1866
1867
1868 rname = argv[1];
1869 if (*rname == '%')
1870 rname++;
1871
1872 diag = kdbgetu64arg(argv[2], ®64);
1873 if (diag)
1874 return diag;
1875
1876 diag = kdb_check_regs();
1877 if (diag)
1878 return diag;
1879
1880 diag = KDB_BADREG;
1881 for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1882 if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1883 diag = 0;
1884 break;
1885 }
1886 }
1887 if (!diag) {
1888 switch(dbg_reg_def[i].size * 8) {
1889 case 8:
1890 reg8 = reg64;
1891 dbg_set_reg(i, ®8, kdb_current_regs);
1892 break;
1893 case 16:
1894 reg16 = reg64;
1895 dbg_set_reg(i, ®16, kdb_current_regs);
1896 break;
1897 case 32:
1898 reg32 = reg64;
1899 dbg_set_reg(i, ®32, kdb_current_regs);
1900 break;
1901 case 64:
1902 dbg_set_reg(i, ®64, kdb_current_regs);
1903 break;
1904 }
1905 }
1906 return diag;
1907#else
1908 kdb_printf("ERROR: Register set currently not implemented\n");
1909 return 0;
1910#endif
1911}
1912
1913#if defined(CONFIG_MAGIC_SYSRQ)
1914
1915
1916
1917
1918
1919static int kdb_sr(int argc, const char **argv)
1920{
1921 if (argc != 1)
1922 return KDB_ARGCOUNT;
1923 kdb_trap_printk++;
1924 __handle_sysrq(*argv[1], false);
1925 kdb_trap_printk--;
1926
1927 return 0;
1928}
1929#endif
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940static int kdb_ef(int argc, const char **argv)
1941{
1942 int diag;
1943 unsigned long addr;
1944 long offset;
1945 int nextarg;
1946
1947 if (argc != 1)
1948 return KDB_ARGCOUNT;
1949
1950 nextarg = 1;
1951 diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1952 if (diag)
1953 return diag;
1954 show_regs((struct pt_regs *)addr);
1955 return 0;
1956}
1957
1958#if defined(CONFIG_MODULES)
1959
1960
1961
1962
1963
1964static int kdb_lsmod(int argc, const char **argv)
1965{
1966 struct module *mod;
1967
1968 if (argc != 0)
1969 return KDB_ARGCOUNT;
1970
1971 kdb_printf("Module Size modstruct Used by\n");
1972 list_for_each_entry(mod, kdb_modules, list) {
1973 if (mod->state == MODULE_STATE_UNFORMED)
1974 continue;
1975
1976 kdb_printf("%-20s%8u 0x%p ", mod->name,
1977 mod->core_size, (void *)mod);
1978#ifdef CONFIG_MODULE_UNLOAD
1979 kdb_printf("%4ld ", module_refcount(mod));
1980#endif
1981 if (mod->state == MODULE_STATE_GOING)
1982 kdb_printf(" (Unloading)");
1983 else if (mod->state == MODULE_STATE_COMING)
1984 kdb_printf(" (Loading)");
1985 else
1986 kdb_printf(" (Live)");
1987 kdb_printf(" 0x%p", mod->module_core);
1988
1989#ifdef CONFIG_MODULE_UNLOAD
1990 {
1991 struct module_use *use;
1992 kdb_printf(" [ ");
1993 list_for_each_entry(use, &mod->source_list,
1994 source_list)
1995 kdb_printf("%s ", use->target->name);
1996 kdb_printf("]\n");
1997 }
1998#endif
1999 }
2000
2001 return 0;
2002}
2003
2004#endif
2005
2006
2007
2008
2009
2010
2011static int kdb_env(int argc, const char **argv)
2012{
2013 int i;
2014
2015 for (i = 0; i < __nenv; i++) {
2016 if (__env[i])
2017 kdb_printf("%s\n", __env[i]);
2018 }
2019
2020 if (KDB_DEBUG(MASK))
2021 kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2022
2023 return 0;
2024}
2025
2026#ifdef CONFIG_PRINTK
2027
2028
2029
2030
2031
2032static int kdb_dmesg(int argc, const char **argv)
2033{
2034 int diag;
2035 int logging;
2036 int lines = 0;
2037 int adjust = 0;
2038 int n = 0;
2039 int skip = 0;
2040 struct kmsg_dumper dumper = { .active = 1 };
2041 size_t len;
2042 char buf[201];
2043
2044 if (argc > 2)
2045 return KDB_ARGCOUNT;
2046 if (argc) {
2047 char *cp;
2048 lines = simple_strtol(argv[1], &cp, 0);
2049 if (*cp)
2050 lines = 0;
2051 if (argc > 1) {
2052 adjust = simple_strtoul(argv[2], &cp, 0);
2053 if (*cp || adjust < 0)
2054 adjust = 0;
2055 }
2056 }
2057
2058
2059 diag = kdbgetintenv("LOGGING", &logging);
2060 if (!diag && logging) {
2061 const char *setargs[] = { "set", "LOGGING", "0" };
2062 kdb_set(2, setargs);
2063 }
2064
2065 kmsg_dump_rewind_nolock(&dumper);
2066 while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
2067 n++;
2068
2069 if (lines < 0) {
2070 if (adjust >= n)
2071 kdb_printf("buffer only contains %d lines, nothing "
2072 "printed\n", n);
2073 else if (adjust - lines >= n)
2074 kdb_printf("buffer only contains %d lines, last %d "
2075 "lines printed\n", n, n - adjust);
2076 skip = adjust;
2077 lines = abs(lines);
2078 } else if (lines > 0) {
2079 skip = n - lines - adjust;
2080 lines = abs(lines);
2081 if (adjust >= n) {
2082 kdb_printf("buffer only contains %d lines, "
2083 "nothing printed\n", n);
2084 skip = n;
2085 } else if (skip < 0) {
2086 lines += skip;
2087 skip = 0;
2088 kdb_printf("buffer only contains %d lines, first "
2089 "%d lines printed\n", n, lines);
2090 }
2091 } else {
2092 lines = n;
2093 }
2094
2095 if (skip >= n || skip < 0)
2096 return 0;
2097
2098 kmsg_dump_rewind_nolock(&dumper);
2099 while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
2100 if (skip) {
2101 skip--;
2102 continue;
2103 }
2104 if (!lines--)
2105 break;
2106 if (KDB_FLAG(CMD_INTERRUPT))
2107 return 0;
2108
2109 kdb_printf("%.*s\n", (int)len - 1, buf);
2110 }
2111
2112 return 0;
2113}
2114#endif
2115
2116
2117static atomic_t kdb_nmi_disabled;
2118
2119static int kdb_disable_nmi(int argc, const char *argv[])
2120{
2121 if (atomic_read(&kdb_nmi_disabled))
2122 return 0;
2123 atomic_set(&kdb_nmi_disabled, 1);
2124 arch_kgdb_ops.enable_nmi(0);
2125 return 0;
2126}
2127
2128static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2129{
2130 if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2131 return -EINVAL;
2132 arch_kgdb_ops.enable_nmi(1);
2133 return 0;
2134}
2135
2136static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2137 .set = kdb_param_enable_nmi,
2138};
2139module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2140
2141
2142
2143
2144
2145
2146
2147static void kdb_cpu_status(void)
2148{
2149 int i, start_cpu, first_print = 1;
2150 char state, prev_state = '?';
2151
2152 kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2153 kdb_printf("Available cpus: ");
2154 for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2155 if (!cpu_online(i)) {
2156 state = 'F';
2157 } else {
2158 state = ' ';
2159 if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2160 state = 'I';
2161 }
2162 if (state != prev_state) {
2163 if (prev_state != '?') {
2164 if (!first_print)
2165 kdb_printf(", ");
2166 first_print = 0;
2167 kdb_printf("%d", start_cpu);
2168 if (start_cpu < i-1)
2169 kdb_printf("-%d", i-1);
2170 if (prev_state != ' ')
2171 kdb_printf("(%c)", prev_state);
2172 }
2173 prev_state = state;
2174 start_cpu = i;
2175 }
2176 }
2177
2178 if (prev_state != 'F') {
2179 if (!first_print)
2180 kdb_printf(", ");
2181 kdb_printf("%d", start_cpu);
2182 if (start_cpu < i-1)
2183 kdb_printf("-%d", i-1);
2184 if (prev_state != ' ')
2185 kdb_printf("(%c)", prev_state);
2186 }
2187 kdb_printf("\n");
2188}
2189
2190static int kdb_cpu(int argc, const char **argv)
2191{
2192 unsigned long cpunum;
2193 int diag;
2194
2195 if (argc == 0) {
2196 kdb_cpu_status();
2197 return 0;
2198 }
2199
2200 if (argc != 1)
2201 return KDB_ARGCOUNT;
2202
2203 diag = kdbgetularg(argv[1], &cpunum);
2204 if (diag)
2205 return diag;
2206
2207
2208
2209
2210 if ((cpunum > NR_CPUS) || !cpu_online(cpunum))
2211 return KDB_BADCPUNUM;
2212
2213 dbg_switch_cpu = cpunum;
2214
2215
2216
2217
2218 return KDB_CMD_CPU;
2219}
2220
2221
2222
2223
2224void kdb_ps_suppressed(void)
2225{
2226 int idle = 0, daemon = 0;
2227 unsigned long mask_I = kdb_task_state_string("I"),
2228 mask_M = kdb_task_state_string("M");
2229 unsigned long cpu;
2230 const struct task_struct *p, *g;
2231 for_each_online_cpu(cpu) {
2232 p = kdb_curr_task(cpu);
2233 if (kdb_task_state(p, mask_I))
2234 ++idle;
2235 }
2236 kdb_do_each_thread(g, p) {
2237 if (kdb_task_state(p, mask_M))
2238 ++daemon;
2239 } kdb_while_each_thread(g, p);
2240 if (idle || daemon) {
2241 if (idle)
2242 kdb_printf("%d idle process%s (state I)%s\n",
2243 idle, idle == 1 ? "" : "es",
2244 daemon ? " and " : "");
2245 if (daemon)
2246 kdb_printf("%d sleeping system daemon (state M) "
2247 "process%s", daemon,
2248 daemon == 1 ? "" : "es");
2249 kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2250 }
2251}
2252
2253
2254
2255
2256
2257
2258void kdb_ps1(const struct task_struct *p)
2259{
2260 int cpu;
2261 unsigned long tmp;
2262
2263 if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2264 return;
2265
2266 cpu = kdb_process_cpu(p);
2267 kdb_printf("0x%p %8d %8d %d %4d %c 0x%p %c%s\n",
2268 (void *)p, p->pid, p->parent->pid,
2269 kdb_task_has_cpu(p), kdb_process_cpu(p),
2270 kdb_task_state_char(p),
2271 (void *)(&p->thread),
2272 p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2273 p->comm);
2274 if (kdb_task_has_cpu(p)) {
2275 if (!KDB_TSK(cpu)) {
2276 kdb_printf(" Error: no saved data for this cpu\n");
2277 } else {
2278 if (KDB_TSK(cpu) != p)
2279 kdb_printf(" Error: does not match running "
2280 "process table (0x%p)\n", KDB_TSK(cpu));
2281 }
2282 }
2283}
2284
2285static int kdb_ps(int argc, const char **argv)
2286{
2287 struct task_struct *g, *p;
2288 unsigned long mask, cpu;
2289
2290 if (argc == 0)
2291 kdb_ps_suppressed();
2292 kdb_printf("%-*s Pid Parent [*] cpu State %-*s Command\n",
2293 (int)(2*sizeof(void *))+2, "Task Addr",
2294 (int)(2*sizeof(void *))+2, "Thread");
2295 mask = kdb_task_state_string(argc ? argv[1] : NULL);
2296
2297 for_each_online_cpu(cpu) {
2298 if (KDB_FLAG(CMD_INTERRUPT))
2299 return 0;
2300 p = kdb_curr_task(cpu);
2301 if (kdb_task_state(p, mask))
2302 kdb_ps1(p);
2303 }
2304 kdb_printf("\n");
2305
2306 kdb_do_each_thread(g, p) {
2307 if (KDB_FLAG(CMD_INTERRUPT))
2308 return 0;
2309 if (kdb_task_state(p, mask))
2310 kdb_ps1(p);
2311 } kdb_while_each_thread(g, p);
2312
2313 return 0;
2314}
2315
2316
2317
2318
2319
2320
2321static int kdb_pid(int argc, const char **argv)
2322{
2323 struct task_struct *p;
2324 unsigned long val;
2325 int diag;
2326
2327 if (argc > 1)
2328 return KDB_ARGCOUNT;
2329
2330 if (argc) {
2331 if (strcmp(argv[1], "R") == 0) {
2332 p = KDB_TSK(kdb_initial_cpu);
2333 } else {
2334 diag = kdbgetularg(argv[1], &val);
2335 if (diag)
2336 return KDB_BADINT;
2337
2338 p = find_task_by_pid_ns((pid_t)val, &init_pid_ns);
2339 if (!p) {
2340 kdb_printf("No task with pid=%d\n", (pid_t)val);
2341 return 0;
2342 }
2343 }
2344 kdb_set_current_task(p);
2345 }
2346 kdb_printf("KDB current process is %s(pid=%d)\n",
2347 kdb_current_task->comm,
2348 kdb_current_task->pid);
2349
2350 return 0;
2351}
2352
2353static int kdb_kgdb(int argc, const char **argv)
2354{
2355 return KDB_CMD_KGDB;
2356}
2357
2358
2359
2360
2361static int kdb_help(int argc, const char **argv)
2362{
2363 kdbtab_t *kt;
2364 int i;
2365
2366 kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2367 kdb_printf("-----------------------------"
2368 "-----------------------------\n");
2369 for_each_kdbcmd(kt, i) {
2370 char *space = "";
2371 if (KDB_FLAG(CMD_INTERRUPT))
2372 return 0;
2373 if (!kt->cmd_name)
2374 continue;
2375 if (strlen(kt->cmd_usage) > 20)
2376 space = "\n ";
2377 kdb_printf("%-15.15s %-20s%s%s\n", kt->cmd_name,
2378 kt->cmd_usage, space, kt->cmd_help);
2379 }
2380 return 0;
2381}
2382
2383
2384
2385
2386static int kdb_kill(int argc, const char **argv)
2387{
2388 long sig, pid;
2389 char *endp;
2390 struct task_struct *p;
2391 struct siginfo info;
2392
2393 if (argc != 2)
2394 return KDB_ARGCOUNT;
2395
2396 sig = simple_strtol(argv[1], &endp, 0);
2397 if (*endp)
2398 return KDB_BADINT;
2399 if (sig >= 0) {
2400 kdb_printf("Invalid signal parameter.<-signal>\n");
2401 return 0;
2402 }
2403 sig = -sig;
2404
2405 pid = simple_strtol(argv[2], &endp, 0);
2406 if (*endp)
2407 return KDB_BADINT;
2408 if (pid <= 0) {
2409 kdb_printf("Process ID must be large than 0.\n");
2410 return 0;
2411 }
2412
2413
2414 p = find_task_by_pid_ns(pid, &init_pid_ns);
2415 if (!p) {
2416 kdb_printf("The specified process isn't found.\n");
2417 return 0;
2418 }
2419 p = p->group_leader;
2420 info.si_signo = sig;
2421 info.si_errno = 0;
2422 info.si_code = SI_USER;
2423 info.si_pid = pid;
2424 info.si_uid = 0;
2425 kdb_send_sig_info(p, &info);
2426 return 0;
2427}
2428
2429struct kdb_tm {
2430 int tm_sec;
2431 int tm_min;
2432 int tm_hour;
2433 int tm_mday;
2434 int tm_mon;
2435 int tm_year;
2436};
2437
2438static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
2439{
2440
2441 static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
2442 31, 30, 31, 30, 31 };
2443 memset(tm, 0, sizeof(*tm));
2444 tm->tm_sec = tv->tv_sec % (24 * 60 * 60);
2445 tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
2446 (2 * 365 + 1);
2447 tm->tm_min = tm->tm_sec / 60 % 60;
2448 tm->tm_hour = tm->tm_sec / 60 / 60;
2449 tm->tm_sec = tm->tm_sec % 60;
2450 tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
2451 tm->tm_mday %= (4*365+1);
2452 mon_day[1] = 29;
2453 while (tm->tm_mday >= mon_day[tm->tm_mon]) {
2454 tm->tm_mday -= mon_day[tm->tm_mon];
2455 if (++tm->tm_mon == 12) {
2456 tm->tm_mon = 0;
2457 ++tm->tm_year;
2458 mon_day[1] = 28;
2459 }
2460 }
2461 ++tm->tm_mday;
2462}
2463
2464
2465
2466
2467
2468
2469static void kdb_sysinfo(struct sysinfo *val)
2470{
2471 struct timespec uptime;
2472 do_posix_clock_monotonic_gettime(&uptime);
2473 memset(val, 0, sizeof(*val));
2474 val->uptime = uptime.tv_sec;
2475 val->loads[0] = avenrun[0];
2476 val->loads[1] = avenrun[1];
2477 val->loads[2] = avenrun[2];
2478 val->procs = nr_threads-1;
2479 si_meminfo(val);
2480
2481 return;
2482}
2483
2484
2485
2486
2487static int kdb_summary(int argc, const char **argv)
2488{
2489 struct timespec now;
2490 struct kdb_tm tm;
2491 struct sysinfo val;
2492
2493 if (argc)
2494 return KDB_ARGCOUNT;
2495
2496 kdb_printf("sysname %s\n", init_uts_ns.name.sysname);
2497 kdb_printf("release %s\n", init_uts_ns.name.release);
2498 kdb_printf("version %s\n", init_uts_ns.name.version);
2499 kdb_printf("machine %s\n", init_uts_ns.name.machine);
2500 kdb_printf("nodename %s\n", init_uts_ns.name.nodename);
2501 kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2502 kdb_printf("ccversion %s\n", __stringify(CCVERSION));
2503
2504 now = __current_kernel_time();
2505 kdb_gmtime(&now, &tm);
2506 kdb_printf("date %04d-%02d-%02d %02d:%02d:%02d "
2507 "tz_minuteswest %d\n",
2508 1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2509 tm.tm_hour, tm.tm_min, tm.tm_sec,
2510 sys_tz.tz_minuteswest);
2511
2512 kdb_sysinfo(&val);
2513 kdb_printf("uptime ");
2514 if (val.uptime > (24*60*60)) {
2515 int days = val.uptime / (24*60*60);
2516 val.uptime %= (24*60*60);
2517 kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2518 }
2519 kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2520
2521
2522
2523#define LOAD_INT(x) ((x) >> FSHIFT)
2524#define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2525 kdb_printf("load avg %ld.%02ld %ld.%02ld %ld.%02ld\n",
2526 LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2527 LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2528 LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2529#undef LOAD_INT
2530#undef LOAD_FRAC
2531
2532#define K(x) ((x) << (PAGE_SHIFT - 10))
2533 kdb_printf("\nMemTotal: %8lu kB\nMemFree: %8lu kB\n"
2534 "Buffers: %8lu kB\n",
2535 val.totalram, val.freeram, val.bufferram);
2536 return 0;
2537}
2538
2539
2540
2541
2542static int kdb_per_cpu(int argc, const char **argv)
2543{
2544 char fmtstr[64];
2545 int cpu, diag, nextarg = 1;
2546 unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2547
2548 if (argc < 1 || argc > 3)
2549 return KDB_ARGCOUNT;
2550
2551 diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2552 if (diag)
2553 return diag;
2554
2555 if (argc >= 2) {
2556 diag = kdbgetularg(argv[2], &bytesperword);
2557 if (diag)
2558 return diag;
2559 }
2560 if (!bytesperword)
2561 bytesperword = KDB_WORD_SIZE;
2562 else if (bytesperword > KDB_WORD_SIZE)
2563 return KDB_BADWIDTH;
2564 sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2565 if (argc >= 3) {
2566 diag = kdbgetularg(argv[3], &whichcpu);
2567 if (diag)
2568 return diag;
2569 if (!cpu_online(whichcpu)) {
2570 kdb_printf("cpu %ld is not online\n", whichcpu);
2571 return KDB_BADCPUNUM;
2572 }
2573 }
2574
2575
2576
2577
2578#ifdef __per_cpu_offset
2579#define KDB_PCU(cpu) __per_cpu_offset(cpu)
2580#else
2581#ifdef CONFIG_SMP
2582#define KDB_PCU(cpu) __per_cpu_offset[cpu]
2583#else
2584#define KDB_PCU(cpu) 0
2585#endif
2586#endif
2587 for_each_online_cpu(cpu) {
2588 if (KDB_FLAG(CMD_INTERRUPT))
2589 return 0;
2590
2591 if (whichcpu != ~0UL && whichcpu != cpu)
2592 continue;
2593 addr = symaddr + KDB_PCU(cpu);
2594 diag = kdb_getword(&val, addr, bytesperword);
2595 if (diag) {
2596 kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2597 "read, diag=%d\n", cpu, addr, diag);
2598 continue;
2599 }
2600 kdb_printf("%5d ", cpu);
2601 kdb_md_line(fmtstr, addr,
2602 bytesperword == KDB_WORD_SIZE,
2603 1, bytesperword, 1, 1, 0);
2604 }
2605#undef KDB_PCU
2606 return 0;
2607}
2608
2609
2610
2611
2612static int kdb_grep_help(int argc, const char **argv)
2613{
2614 kdb_printf("Usage of cmd args | grep pattern:\n");
2615 kdb_printf(" Any command's output may be filtered through an ");
2616 kdb_printf("emulated 'pipe'.\n");
2617 kdb_printf(" 'grep' is just a key word.\n");
2618 kdb_printf(" The pattern may include a very limited set of "
2619 "metacharacters:\n");
2620 kdb_printf(" pattern or ^pattern or pattern$ or ^pattern$\n");
2621 kdb_printf(" And if there are spaces in the pattern, you may "
2622 "quote it:\n");
2623 kdb_printf(" \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2624 " or \"^pat tern$\"\n");
2625 return 0;
2626}
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640#define kdb_command_extend 50
2641int kdb_register_repeat(char *cmd,
2642 kdb_func_t func,
2643 char *usage,
2644 char *help,
2645 short minlen,
2646 kdb_repeat_t repeat)
2647{
2648 int i;
2649 kdbtab_t *kp;
2650
2651
2652
2653
2654 for_each_kdbcmd(kp, i) {
2655 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2656 kdb_printf("Duplicate kdb command registered: "
2657 "%s, func %p help %s\n", cmd, func, help);
2658 return 1;
2659 }
2660 }
2661
2662
2663
2664
2665 for_each_kdbcmd(kp, i) {
2666 if (kp->cmd_name == NULL)
2667 break;
2668 }
2669
2670 if (i >= kdb_max_commands) {
2671 kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2672 kdb_command_extend) * sizeof(*new), GFP_KDB);
2673 if (!new) {
2674 kdb_printf("Could not allocate new kdb_command "
2675 "table\n");
2676 return 1;
2677 }
2678 if (kdb_commands) {
2679 memcpy(new, kdb_commands,
2680 (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2681 kfree(kdb_commands);
2682 }
2683 memset(new + kdb_max_commands - KDB_BASE_CMD_MAX, 0,
2684 kdb_command_extend * sizeof(*new));
2685 kdb_commands = new;
2686 kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2687 kdb_max_commands += kdb_command_extend;
2688 }
2689
2690 kp->cmd_name = cmd;
2691 kp->cmd_func = func;
2692 kp->cmd_usage = usage;
2693 kp->cmd_help = help;
2694 kp->cmd_flags = 0;
2695 kp->cmd_minlen = minlen;
2696 kp->cmd_repeat = repeat;
2697
2698 return 0;
2699}
2700EXPORT_SYMBOL_GPL(kdb_register_repeat);
2701
2702
2703
2704
2705
2706
2707
2708
2709
2710
2711
2712
2713
2714
2715int kdb_register(char *cmd,
2716 kdb_func_t func,
2717 char *usage,
2718 char *help,
2719 short minlen)
2720{
2721 return kdb_register_repeat(cmd, func, usage, help, minlen,
2722 KDB_REPEAT_NONE);
2723}
2724EXPORT_SYMBOL_GPL(kdb_register);
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734
2735int kdb_unregister(char *cmd)
2736{
2737 int i;
2738 kdbtab_t *kp;
2739
2740
2741
2742
2743 for_each_kdbcmd(kp, i) {
2744 if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2745 kp->cmd_name = NULL;
2746 return 0;
2747 }
2748 }
2749
2750
2751 return 1;
2752}
2753EXPORT_SYMBOL_GPL(kdb_unregister);
2754
2755
2756static void __init kdb_inittab(void)
2757{
2758 int i;
2759 kdbtab_t *kp;
2760
2761 for_each_kdbcmd(kp, i)
2762 kp->cmd_name = NULL;
2763
2764 kdb_register_repeat("md", kdb_md, "<vaddr>",
2765 "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2766 KDB_REPEAT_NO_ARGS);
2767 kdb_register_repeat("mdr", kdb_md, "<vaddr> <bytes>",
2768 "Display Raw Memory", 0, KDB_REPEAT_NO_ARGS);
2769 kdb_register_repeat("mdp", kdb_md, "<paddr> <bytes>",
2770 "Display Physical Memory", 0, KDB_REPEAT_NO_ARGS);
2771 kdb_register_repeat("mds", kdb_md, "<vaddr>",
2772 "Display Memory Symbolically", 0, KDB_REPEAT_NO_ARGS);
2773 kdb_register_repeat("mm", kdb_mm, "<vaddr> <contents>",
2774 "Modify Memory Contents", 0, KDB_REPEAT_NO_ARGS);
2775 kdb_register_repeat("go", kdb_go, "[<vaddr>]",
2776 "Continue Execution", 1, KDB_REPEAT_NONE);
2777 kdb_register_repeat("rd", kdb_rd, "",
2778 "Display Registers", 0, KDB_REPEAT_NONE);
2779 kdb_register_repeat("rm", kdb_rm, "<reg> <contents>",
2780 "Modify Registers", 0, KDB_REPEAT_NONE);
2781 kdb_register_repeat("ef", kdb_ef, "<vaddr>",
2782 "Display exception frame", 0, KDB_REPEAT_NONE);
2783 kdb_register_repeat("bt", kdb_bt, "[<vaddr>]",
2784 "Stack traceback", 1, KDB_REPEAT_NONE);
2785 kdb_register_repeat("btp", kdb_bt, "<pid>",
2786 "Display stack for process <pid>", 0, KDB_REPEAT_NONE);
2787 kdb_register_repeat("bta", kdb_bt, "[D|R|S|T|C|Z|E|U|I|M|A]",
2788 "Backtrace all processes matching state flag", 0, KDB_REPEAT_NONE);
2789 kdb_register_repeat("btc", kdb_bt, "",
2790 "Backtrace current process on each cpu", 0, KDB_REPEAT_NONE);
2791 kdb_register_repeat("btt", kdb_bt, "<vaddr>",
2792 "Backtrace process given its struct task address", 0,
2793 KDB_REPEAT_NONE);
2794 kdb_register_repeat("env", kdb_env, "",
2795 "Show environment variables", 0, KDB_REPEAT_NONE);
2796 kdb_register_repeat("set", kdb_set, "",
2797 "Set environment variables", 0, KDB_REPEAT_NONE);
2798 kdb_register_repeat("help", kdb_help, "",
2799 "Display Help Message", 1, KDB_REPEAT_NONE);
2800 kdb_register_repeat("?", kdb_help, "",
2801 "Display Help Message", 0, KDB_REPEAT_NONE);
2802 kdb_register_repeat("cpu", kdb_cpu, "<cpunum>",
2803 "Switch to new cpu", 0, KDB_REPEAT_NONE);
2804 kdb_register_repeat("kgdb", kdb_kgdb, "",
2805 "Enter kgdb mode", 0, KDB_REPEAT_NONE);
2806 kdb_register_repeat("ps", kdb_ps, "[<flags>|A]",
2807 "Display active task list", 0, KDB_REPEAT_NONE);
2808 kdb_register_repeat("pid", kdb_pid, "<pidnum>",
2809 "Switch to another task", 0, KDB_REPEAT_NONE);
2810 kdb_register_repeat("reboot", kdb_reboot, "",
2811 "Reboot the machine immediately", 0, KDB_REPEAT_NONE);
2812#if defined(CONFIG_MODULES)
2813 kdb_register_repeat("lsmod", kdb_lsmod, "",
2814 "List loaded kernel modules", 0, KDB_REPEAT_NONE);
2815#endif
2816#if defined(CONFIG_MAGIC_SYSRQ)
2817 kdb_register_repeat("sr", kdb_sr, "<key>",
2818 "Magic SysRq key", 0, KDB_REPEAT_NONE);
2819#endif
2820#if defined(CONFIG_PRINTK)
2821 kdb_register_repeat("dmesg", kdb_dmesg, "[lines]",
2822 "Display syslog buffer", 0, KDB_REPEAT_NONE);
2823#endif
2824 if (arch_kgdb_ops.enable_nmi) {
2825 kdb_register_repeat("disable_nmi", kdb_disable_nmi, "",
2826 "Disable NMI entry to KDB", 0, KDB_REPEAT_NONE);
2827 }
2828 kdb_register_repeat("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2829 "Define a set of commands, down to endefcmd", 0, KDB_REPEAT_NONE);
2830 kdb_register_repeat("kill", kdb_kill, "<-signal> <pid>",
2831 "Send a signal to a process", 0, KDB_REPEAT_NONE);
2832 kdb_register_repeat("summary", kdb_summary, "",
2833 "Summarize the system", 4, KDB_REPEAT_NONE);
2834 kdb_register_repeat("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2835 "Display per_cpu variables", 3, KDB_REPEAT_NONE);
2836 kdb_register_repeat("grephelp", kdb_grep_help, "",
2837 "Display help on | grep", 0, KDB_REPEAT_NONE);
2838}
2839
2840
2841static void __init kdb_cmd_init(void)
2842{
2843 int i, diag;
2844 for (i = 0; kdb_cmds[i]; ++i) {
2845 diag = kdb_parse(kdb_cmds[i]);
2846 if (diag)
2847 kdb_printf("kdb command %s failed, kdb diag %d\n",
2848 kdb_cmds[i], diag);
2849 }
2850 if (defcmd_in_progress) {
2851 kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2852 kdb_parse("endefcmd");
2853 }
2854}
2855
2856
2857void __init kdb_init(int lvl)
2858{
2859 static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2860 int i;
2861
2862 if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2863 return;
2864 for (i = kdb_init_lvl; i < lvl; i++) {
2865 switch (i) {
2866 case KDB_NOT_INITIALIZED:
2867 kdb_inittab();
2868 kdb_initbptab();
2869 break;
2870 case KDB_INIT_EARLY:
2871 kdb_cmd_init();
2872 break;
2873 }
2874 }
2875 kdb_init_lvl = lvl;
2876}
2877